基于springboot搭建的web系统架构的方法步骤

从接触springboot开始，便深深的被它的简洁性深深的折服了，精简的配置，方便的集成，使我再也不想用传统的ssm框架来搭建项目，一大堆的配置文件，维护起来很不方便，集成的时候也要费力不少。从第一次使用springboot开始，一个简单的main方法，甚至一个配置文件也不需要（当然我是指的没有任何数据交互，没有任何组件集成的情况），就可以把一个web项目启动起来，下面总结一下自从使用springboot依赖，慢慢完善的自己的一个web系统的架构，肯定不是最好的，但平时自己用着很舒服。

站在用户的角度思考问题，与客户深入沟通，找到黄山区网站设计与黄山区网站推广的解决方案，凭借多年的经验，让设计与互联网技术结合，创造个性化、用户体验好的作品，建站类型包括：成都网站制作、成都网站建设、企业官网、英文网站、手机端网站、网站推广、域名注册、雅安服务器托管、企业邮箱。业务覆盖黄山区地区。

1. 配置信息放到数据库里边

个人比较不喜欢配置文件，因此有一个原则，配置文件能不用就不用，配置信息能少些就少些，配置内容能用代码写坚决不用xml，因此我第一个想到的就是，能不能把springboot的配置信息写到数据库里，在springboot启动的时候自动去加载，而在application.properties里边只写一个数据源。最终找到了方法：

注意图中箭头指向的两行，构造了一个properties对象，然后将这个对象放到了springboot的启动对象application中，properties是一个类似map的key-value容器，springboot可以将其中的东西当做成原来application.properties中的内容一样，因此在properties对象的内容也就相当于写在了application.properties文件中。知道了这个之后就简单了，我们将原本需要写在application.properties中的所有配置信息写在数据库中，在springboot启动的时候从数据库中读取出来放到properties对象中，然后再将这个对象set到application中即可。上图中PropertyConfig.loadProperties()方法就是进行了这样的操作，代码如下：

PropertyConfig.java

public class PropertyConfig {

  /**
   * 生成Properties对象
   */
  public static Properties loadProperties() {
    Properties properties = new Properties();
    loadPropertiesFromDb(properties);
    return properties;
  }

  /**
   * 从数据库中加载配置信息
   */
  private static void loadPropertiesFromDb(Properties properties) {
    InputStream in = PropertyConfig.class.getClassLoader().getResourceAsStream("application.properties");
    try {
      properties.load(in);
    } catch (Exception e) {
      e.printStackTrace();
    }
    String profile = properties.getProperty("profile");
    String driverClassName = properties.getProperty("spring.datasource.driver-class-name");
    String url = properties.getProperty("spring.datasource.url");
    String userName = properties.getProperty("spring.datasource.username");
    String password = properties.getProperty("spring.datasource.password");

    Connection conn = null;
    PreparedStatement pstmt = null;
    ResultSet rs = null;
    try {
      Class.forName(driverClassName);
      String tableName = "t_config_dev";
      if ("pro".equals(profile)) {
        tableName = "t_config_pro";
      }
      String sql = "select * from " + tableName;
      conn = DriverManager.getConnection(url, userName, password);
      pstmt = conn.prepareStatement(sql);
      rs = pstmt.executeQuery();
      while (rs.next()) {
        String key = rs.getString("key");
        String value = rs.getString("value");
        properties.put(key, value);
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        if (conn != null) {
          conn.close();
        }
        if (pstmt != null) {
          pstmt.close();
        }
        if (rs != null) {
          rs.close();
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }

}

代码中，首先使用古老的jdbc技术，读取数据库t_config表，将表中的key-value加载到properties中，代码中profile是为了区分开发环境和生产环境，以便于确定从那张表中加载配置文件，数据库中的配置信息如下：

基于springboot搭建的web系统架构的方法步骤

这样以后，application.properties中就不用再写很多的配置信息，而且，如果将这些配置信息放到数据库中之后，如果起多个应用可是公用这一张表，这样也可以做到配置信息的公用的效果，这样修改以后，配置文件中就只有数据源的信息了：

基于springboot搭建的web系统架构的方法步骤

profile代表使用哪个环境，代码中可以根据这个信息来从开发表中加载配置信息还是从生产表中加载配置信息。

2. 统一返回结果

一般web项目中，大多数都是接口，以返回json数据为主，因此统一一个返回格式很必要。在本示例中，建了一个BaseController，所有的Controller都需要继承这个类，在这个BaseController中定义了成功的返回和失败的返回，在其他业务的Controller中，返回的时候，只需要return super.success(xxx)或者return super.fail(xxx, xxx)即可，例：

基于springboot搭建的web系统架构的方法步骤

说到这里，返回给前台的状态码，建议也是封装成一个枚举类型，不建议直接返回200、400之类的，不方便维护也不方便查询。那么BaseController里做了什么呢？如下：

基于springboot搭建的web系统架构的方法步骤

定义一个ResultInfo类，该类只有两个属性，一个是Integer类型的状态码，一个是泛型，用于成功时返回给前台的数据，和失败时返回给前台的提示信息。

3. 统一异常捕获

在上一步中的Controller代码中看到抛出了一个自定义的异常，在Controller中，属于最外层的代码了，这个时候如果有异常就不能直接抛出去了，这里再抛出去就没有人处理了，服务器只能返回给前台一个错误，用户体验不好。因此，建议所有的Controller代码都用try-catch包裹，捕获到异常后统一进行处理，然后再给前台一个合理的提示信息。在上一步中抛出了一个自定义异常：

throw new MyException(ResultEnum.DELETE_ERROR.getCode(), "删除员工出错，请联系网站管理人员。", e);

该自定义异常有三个属性，分别是异常状态码，异常提示信息，以及捕获到的异常对象，接下来定义一个全局的异常捕获，统一对异常进行处理：

@Slf4j
@ResponseBody
@ControllerAdvice
public class GlobalExceptionHandle {

  /**
   * 处理捕获的异常
   */
  @ExceptionHandler(value = Exception.class)
  public Object handleException(Exception e, HttpServletRequest request, HttpServletResponse resp) throws IOException {
    log.error(AppConst.ERROR_LOG_PREFIX + "请求地址：" + request.getRequestURL().toString());
    log.error(AppConst.ERROR_LOG_PREFIX + "请求方法：" + request.getMethod());
    log.error(AppConst.ERROR_LOG_PREFIX + "请求者IP：" + request.getRemoteAddr());
    log.error(AppConst.ERROR_LOG_PREFIX + "请求参数：" + ParametersUtils.getParameters(request));
    if (e instanceof MyException) {
      MyException myException = (MyException) e;
      log.error(AppConst.ERROR_LOG_PREFIX + myException.getMsg(), myException.getE());
      if (myException.getCode().equals(ResultEnum.SEARCH_PAGE_ERROR.getCode())) {
        JSONObject result = new JSONObject();
        result.put("code", myException.getCode());
        result.put("msg", myException.getMsg());
        return result;
      } else if (myException.getCode().equals(ResultEnum.ERROR_PAGE.getCode())) {
        resp.sendRedirect("/err");
        return "";
      } else {
        return new ResultInfo<>(myException.getCode(), myException.getMsg());
      }
    } else if (e instanceof UnauthorizedException) {
      resp.sendRedirect("/noauth");
      return "";
    } else {
      log.error(AppConst.ERROR_LOG_PREFIX + "错误信息：", e);
    }
    resp.sendRedirect("/err");
    return "";
  }

}

统一捕获异常之后，可以进行相应的处理，我这里没有进行特殊的处理，只是进行了一下区分，获取数据的接口抛出的异常，前台肯定是使用的ajax请求，因此返回前台一个json格式的信息，提示出错误内容。如果是跳转页面抛出的异常，类似404之类的，直接跳转到自定义的404页面。补充一点，springboot项目默认是有/error路由的，返回的就是error页面，所以，如果你在你的项目中定义一个error.html的页面，如果报404错误，会自动跳转到该页面。

补充，统一异常处理类中使用了一个注解@Slf4j，该注解是lombok包中的，项目中加入了该依赖后，再也不用写繁琐的get、set等代码，当然类似的像上边的声明log对象的代码也不用写了：

基于springboot搭建的web系统架构的方法步骤

4. 日志配置文件区分环境

本示例使用的是logback日志框架。需要在resources目录中添加logback.xml配置文件，这是一个比较头疼的地方，我本来想一个配置文件也没有的，奈何我也不知道怎么将这个日志的配置文件放到数据库中，所以暂时先这么着了，好在几乎没有需要改动它的时候。

我在项目中添加了两个日志的配置文件，分别是logback-dev.xml和logback-pro.xml可以根据不同的环境决定使用哪个配置文件，在数据库配置表中（相当于写在了application.properties中）添加一条配置logging.config=classpath:logback-dev.xml来区分使用哪个文件作为日志的配置文件，配置文件内容如下：

logback.xml

<?xml version="1.0" encoding="UTF-8"?>


  
  
  
    ${LOG_HOME}/demo.info.log
    
      ${LOG_HOME}/demo.info.%d{yyyy-MM-dd}.log
      180
    
    
      %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n
      UTF-8
    
  

  
  
    ${LOG_HOME}/demo.error.log
    
      ${LOG_HOME}/demo.error.%d{yyyy-MM-dd}.log
      180
    
    
      %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n
      UTF-8
    
  

  
  
    ${LOG_HOME}/demo.debug.log
    
      ${LOG_HOME}/demo.debug.%d{yyyy-MM-dd}.log
      180
    
    
      %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n
      UTF-8
    
  

  
  
    
      %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger - %msg%n

在配置文件中，定义了三个级别的日志，info、debug和error分别输出到三个文件中，便于查看。在生成日志文件的时候，进行了按照日志进行拆分的配置，每一个级别的日志每一天都会重新生成一个，根据日期进行命名，超过180天的日志将自动会删除。当然你还可以按照日志大小进行拆分，我这里没有进行这项的配置。

5. 全局接口请求记录

进行全局的接口请求记录，可以记录接口的别调用情况，然后进行一些统计和分析，在本示例中，只是将全局的接口调用情况记录到了info日志中，没有进行相应的分析操作：

@Slf4j
@Aspect
@Component
public class WebLogAspect {

  @Pointcut("execution(public * com.oven.controller.*.*(..))")
  public void webLog() {
  }

  @Before("webLog()")
  public void doBefore() {
    // 获取请求
    ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
    @SuppressWarnings("ConstantConditions") HttpServletRequest request = attributes.getRequest();
    // 记录请求内容
    log.info(AppConst.INFO_LOG_PREFIX + "请求地址：" + request.getRequestURL().toString());
    log.info(AppConst.INFO_LOG_PREFIX + "请求方法：" + request.getMethod());
    log.info(AppConst.INFO_LOG_PREFIX + "请求者IP：" + request.getRemoteAddr());
    log.info(AppConst.INFO_LOG_PREFIX + "请求参数：" + ParametersUtils.getParameters(request));
  }

  @AfterReturning(returning = "ret", pointcut = "webLog()")
  public void doAfterReturning(Object ret) {
    // 请求返回的内容
    if (ret instanceof ResultInfo) {
      log.info(AppConst.INFO_LOG_PREFIX + "返回结果：" + ((ResultInfo) ret).getCode().toString());
    }
  }

}

6. 集成shiro实现权限校验

集成shirl，轻松的实现了权限的管理，如果对shiro不熟悉朋友，还需要先把shiro入门一下才好，shiro的集成一般都需要自定义一个realm，来进行身份认证和授权，因此先来一个自定义realm：

MyShiroRealm.java

public class MyShiroRealm extends AuthorizingRealm {

  @Resource
  private MenuService menuService;
  @Resource
  private UserService userService;

  /**
   * 授权
   */
  @Override
  protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principals) {
    SimpleAuthorizationInfo authorizationInfo = new SimpleAuthorizationInfo();
    User user = (User) principals.getPrimaryPrincipal();
    List permissions = menuService.getAllMenuCodeByUserId(user.getId());
    authorizationInfo.addStringPermissions(permissions);
    return authorizationInfo;
  }

  /**
   * 身份认证
   */
  @Override
  protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
    UsernamePasswordToken token = (UsernamePasswordToken) authenticationToken;
    String userName = String.valueOf(token.getUsername());
    // 从数据库获取对应用户名的用户
    User user = userService.getByUserName(userName);
    // 账号不存在
    if (user == null) {
      throw new UnknownAccountException(ResultEnum.NO_THIS_USER.getValue());
    }

    Md5Hash md5 = new Md5Hash(token.getPassword(), AppConst.MD5_SALT, 2);
    // 密码错误
    if (!md5.toString().equals(user.getPassword())) {
      throw new IncorrectCredentialsException(ResultEnum.PASSWORD_WRONG.getValue());
    }

    // 账号锁定
    if (user.getStatus().equals(1)) {
      throw new LockedAccountException(ResultEnum.USER_DISABLE.getValue());
    }
    ByteSource salt = ByteSource.Util.bytes(AppConst.MD5_SALT);
    return new SimpleAuthenticationInfo(user, user.getPassword(), salt, getName());
  }

}

自定义完realm后需要一个配置文件但自定义的realm配置到shiro里：

ShiroConfig.java

@Configuration
public class ShiroConfig {

  @Bean
  public ShiroFilterFactoryBean shirFilter(SecurityManager securityManager) {
    ShiroFilterFactoryBean shiroFilterFactoryBean = new ShiroFilterFactoryBean();
    shiroFilterFactoryBean.setSecurityManager(securityManager);
    Map filterChainDefinitionMap = new LinkedHashMap<>();
    filterChainDefinitionMap.put("/static/**", "anon");
    filterChainDefinitionMap.put("/css/**", "anon");
    filterChainDefinitionMap.put("/font/**", "anon");
    filterChainDefinitionMap.put("/js/**", "anon");
    filterChainDefinitionMap.put("/*.js", "anon");
    filterChainDefinitionMap.put("/login", "anon");
    filterChainDefinitionMap.put("/doLogin", "anon");
    filterChainDefinitionMap.put("/**", "authc");
    shiroFilterFactoryBean.setLoginUrl("/login");
    shiroFilterFactoryBean.setSuccessUrl("/");
    shiroFilterFactoryBean.setUnauthorizedUrl("/noauth");
    shiroFilterFactoryBean.setFilterChainDefinitionMap(filterChainDefinitionMap);
    return shiroFilterFactoryBean;
  }

  /**
   * 凭证匹配器
   */
  @Bean
  public HashedCredentialsMatcher hashedCredentialsMatcher() {
    HashedCredentialsMatcher hashedCredentialsMatcher = new HashedCredentialsMatcher();
    hashedCredentialsMatcher.setHashAlgorithmName("MD5");
    hashedCredentialsMatcher.setHashIterations(2);
    return hashedCredentialsMatcher;
  }

  @Bean
  public MyShiroRealm myShiroRealm() {
    MyShiroRealm myShiroRealm = new MyShiroRealm();
    myShiroRealm.setCredentialsMatcher(hashedCredentialsMatcher());
    return myShiroRealm;
  }


  @Bean
  public SecurityManager securityManager() {
    DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
    securityManager.setRealm(myShiroRealm());
    return securityManager;
  }

  /**
   * 开启shiro aop注解
   */
  @Bean
  public AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor(SecurityManager securityManager) {
    AuthorizationAttributeSourceAdvisor authorizationAttributeSourceAdvisor = new AuthorizationAttributeSourceAdvisor();
    authorizationAttributeSourceAdvisor.setSecurityManager(securityManager);
    return authorizationAttributeSourceAdvisor;
  }

  @Bean(name = "simpleMappingExceptionResolver")
  public SimpleMappingExceptionResolver
  createSimpleMappingExceptionResolver() {
    SimpleMappingExceptionResolver r = new SimpleMappingExceptionResolver();
    Properties mappings = new Properties();
    mappings.setProperty("DatabaseException", "databaseError");
    mappings.setProperty("UnauthorizedException", "403");
    r.setExceptionMappings(mappings);
    r.setDefaultErrorView("error");
    r.setExceptionAttribute("ex");
    return r;
  }

}

身份认证如果简单的理解的话，你可以理解为登录的过程。授权就是授予你权利，代表你在这个系统中有权限做什么动作，具体shiro的内容小伙伴们自行去学习吧。

7. 登录校验，安全拦截

在集成了shiro之后，登录操作就需要使用到自定义的realm了，具体的登录代码如下：

/**
   * 登录操作
   *
   * @param userName 用户名
   * @param pwd   密码
   */
  @RequestMapping("/doLogin")
  @ResponseBody
  public Object doLogin(String userName, String pwd, HttpServletRequest req) throws MyException {
    try {
      Subject subject = SecurityUtils.getSubject();
      UsernamePasswordToken token = new UsernamePasswordToken(userName, pwd);
      subject.login(token);

      User userInDb = userService.getByUserName(userName);
      // 登录成功后放入application，防止同一个账户多人登录
      ServletContext application = req.getServletContext();
      @SuppressWarnings("unchecked")
      Map loginedMap = (Map) application.getAttribute(AppConst.LOGINEDUSERS);
      if (loginedMap == null) {
        loginedMap = new HashMap<>();
        application.setAttribute(AppConst.LOGINEDUSERS, loginedMap);
      }
      loginedMap.put(userInDb.getUserName(), req.getSession().getId());

      // 登录成功后放入session中
      req.getSession().setAttribute(AppConst.CURRENT_USER, userInDb);
      logService.addLog("登录系统！", "成功！", userInDb.getId(), userInDb.getNickName(), IPUtils.getClientIPAddr(req));
      return super.success("登录成功！");
    } catch (Exception e) {
      User userInDb = userService.getByUserName(userName);
      if (e instanceof UnknownAccountException) {
        logService.addLog("登录系统！", "失败[" + ResultEnum.NO_THIS_USER.getValue() + "]", 0, "", IPUtils.getClientIPAddr(req));
        return super.fail(ResultEnum.NO_THIS_USER.getCode(), ResultEnum.NO_THIS_USER.getValue());
      } else if (e instanceof IncorrectCredentialsException) {
        logService.addLog("登录系统！", "失败[" + ResultEnum.PASSWORD_WRONG.getValue() + "]", userInDb.getId(), userInDb.getNickName(), IPUtils.getClientIPAddr(req));
        return super.fail(ResultEnum.PASSWORD_WRONG.getCode(), ResultEnum.PASSWORD_WRONG.getValue());
      } else if (e instanceof LockedAccountException) {
        logService.addLog("登录系统！", "失败[" + ResultEnum.USER_DISABLE.getValue() + "]", userInDb.getId(), userInDb.getNickName(), IPUtils.getClientIPAddr(req));
        return super.fail(ResultEnum.USER_DISABLE.getCode(), ResultEnum.USER_DISABLE.getValue());
      } else {
        throw new MyException(ResultEnum.UNKNOW_ERROR.getCode(), "登录操作出错，请联系网站管理人员。", e);
      }
    }
  }

身份认证的操作交给了shiro，利用用户名和密码构造一个身份的令牌，调用shiro的login方法，这个时候就会进入自定义reaml的身份认证方法中，也就是上一步中的doGetAuthenticationInfo方法，具体的认证操作看上一步的代码，无非就是账号密码的校验等。身份认证的时候，通过抛出异常的方式给登录操作返回信息，从而在登录方法中判断身份认证失败后的信息，从而返回给前台进行提示。

在身份认证通过后，拿到当前登录用户的信息，首先放到session中，便于后续的使用。其次在放到application对象中，防止同一个账号的多次登录。

有了身份任何和授权自然就少不了安全校验，在本示例中使用了一个拦截器来实现安全校验的工作：

SecurityInterceptor.java

@Component
public class SecurityInterceptor extends HandlerInterceptorAdapter {

  @Override
  public boolean preHandle(HttpServletRequest req, HttpServletResponse resp, Object handler) throws Exception {
    resp.setContentType("text/plain;charset=UTF-8");
    String servletPath = req.getServletPath();
    // 放行的请求
    if (servletPath.startsWith("/login") || servletPath.startsWith("/doLogin") || servletPath.equals("/err")) {
      return true;
    }
    if (servletPath.startsWith("/error")) {
      resp.sendRedirect("/err");
      return true;
    }

    // 获取当前登录用户
    User user = (User) req.getSession().getAttribute(AppConst.CURRENT_USER);

    // 没有登录状态下访问系统主页面，都跳转到登录页，不提示任何信息
    if (servletPath.startsWith("/")) {
      if (user == null) {
        resp.sendRedirect(getDomain(req) + "/login");
        return false;
      }
    }

    // 未登录或会话超时
    if (user == null) {
      String requestType = req.getHeader("X-Requested-With");
      if ("XMLHttpRequest".equals(requestType)) { // ajax请求
        ResultInfo

甜橘子，专注成都网站制作网站设计与营销型网站建设与优化

首页

网站建设

网站制作案例

解决方案

网站设计报价

网站制作动态

关于我们

联系我们

成都网站建设设计将想法与焦点和您一起共享

基于springboot搭建的web系统架构的方法步骤

其他资讯

mysql怎么建外键 mysql建立外键

android颜色控制 android颜色代码

mysql命令登录怎么用 mysql 命令登陆

css样式类华 css样式三种类型

android黄油网盘安卓黄油百度网盘链接

甜橘子，专注成都网站制作网站设计与营销型网站建设与优化

成都网站建设设计 将想法与焦点和您一起共享

基于springboot搭建的web系统架构的方法步骤

其他资讯

mysql怎么建外键 mysql建立外键

android颜色控制 android颜色代码

mysql命令登录怎么用 mysql 命令登陆

css样式类华 css样式三种类型

android黄油网盘 安卓黄油百度网盘链接

成都网站建设设计将想法与焦点和您一起共享

android黄油网盘安卓黄油百度网盘链接