超全面SpringBoot实战企业项目框架搭建

立即下载用AI写一个

发布时间：2019-12-18

45人 | 浏览：12336次 | 收藏 |

技术：SpringBoot+MyBatis+SpringSecurity+JWT+Swagger2+Redis+MySQL+逆向工程

运行环境：springboot2.0.2+jdk1.8+MySQL5.7

概述

此框架是本人在工作当中自主搭建的一套基于Springboot的开发框架，目前已投入多个项目的使用当中，对于框架的性能有了一个很好的验证，项目包含完整的开发处理体系。例如：用户权限验证，安全访问，全局异常处理，日志定向输出，打包部署等，有一些列的解决方案！不论是学习，还是搭建项目实战框架，都是大有裨益！

详细

## SpringBoot+MyBatis+SpringSecurity+JWT超全面实战项目框架搭建

### 前言
此框架是本人在工作当中自主搭建的一套基于Springboot的开发框架 ，目前已投入多个项目的使用当中，对于框架的性能有了一个很好的验证，项目包含完整的开发处理体系。例如：用户权限验证，安全访问，全局异常处理，日志定向输出，打包部署等，有一些列的解决方案！不论是学习，还是搭建项目实战框架，都是大有裨益！

框架只做了权限管理模块，绝对干净，定制性高

### 概述
#### 框架大致包含以下内容：
- Springboot
- Mybatis
- Mybatis逆向工程
- Springsecurity
- Jwt(Json Wbe Token)
- Swagger2
- Redis
- Mysql
- 全局异常处理
- 日志处理

#### 架构图：
![](/contentImages/image/20191217/mMPtC4EOiN4O0K6RaZ1.png)

## 详细
### 一、项目简介
在使用本项目之前，需要对SpringBoot , SpringSecurity , JWT , Swagger等基本操作有所了解。
本项目已经实现了权限管理模块，可直接复用，或者自己开发均可。

具体会在下文说明。
#### 项目结构图：
##### 总览：

![](/contentImages/image/20191217/MsE4CZz0GW1ccgaP8Pd.png)

##### 详细：
![](/contentImages/image/20191217/Y9boqEZhYpdXXxY3mqD.png)

![](/contentImages/image/20191217/fkmD5W9vL69nsnbM6t8.png)

### 项目实现的功能
#### 1.数据库连接：application-dev.yml
采用阿里巴巴druid数据库连接池
```
spring:
  profiles: dev
  datasource:
      name: mysql
      type: com.alibaba.druid.pool.DruidDataSource
      #druid相关配置
      druid:
        #监控统计拦截的filters
        filters: stat
        driver-class-name: com.mysql.jdbc.Driver
        #基本属性
        url: jdbc:mysql://localhost:3306/choose_goods?useUnicode=true&characterEncoding=UTF-8&allowMultiQueries=true&useSSL=false
        username: sskj
        password: root
        #配置初始化大小/最小/最大
        initial-size: 1
        min-idle: 1
        max-active: 20
        #获取连接等待超时时间
        max-wait: 60000
        #间隔多久进行一次检测，检测需要关闭的空闲连接
        time-between-eviction-runs-millis: 60000
        #一个连接在池中最小生存的时间
        min-evictable-idle-time-millis: 300000
        validation-query: SELECT 'x'
        test-while-idle: true
        test-on-borrow: false
        test-on-return: false
        #打开PSCache，并指定每个连接上PSCache的大小。oracle设为true，mysql设为false。分库分表较多推荐设置为false
        pool-prepared-statements: false
        max-pool-prepared-statement-per-connection-size: 20
  redis:
    host: 127.0.0.1
    port: 6379
    password: test

logging:
  level:
      root: info
      com:
           sskjdata:
                   cg:
                      dao: debug
  file: logs/spring.log
server:
  port: 8081

jwt:
  # token 有效时长：单位 秒
  #expiration: 604800
  expiration: 120

pagehelper:
  offset-as-page-num: true
  row-bounds-with-count: true
  reasonable: true

```

#### 2.SpringSecurity安全框架
自定义个性化对资源进行管理，定义放行资源，以及某些资源的访问权限控制。
例如：/auth/**，该接口下的所有映射接口，所有角色，所有权限均可访问

```
/**
 * @Desciption 安全配置
 * @Author Jason
 * @Date 2018/6/18 21:02
 */
@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {

@Autowired
    @Qualifier("jwtUserDetailsServiceImpl")
    private UserDetailsService userDetailsService;

@Autowired
    private JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;

@Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                // 基于token，所以不需要session
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)
                .and()
                .authorizeRequests()
                .antMatchers(
                        "/",
                        "/*.html", // 放行swagger
                        "/public/**",
                        "/**/*.html",
                        "/**/*.js",
                        "/**/*.css",
                        "/**/*.jpg",
                        "/**/*.jpeg",
                        "/**/*.png",
                        "/**/*.gif",
                        "/**/*.text",
                        "/**/*.txt",
                        "/**/*.woff2",
                        "/swagger-resources/**",
                        "/webjars/**",
                        "/v2/**",
                        "/swagger-ui.html/**",
                        "/chooseScenes/**",
                        "/**"
                )
                .permitAll()
                // 对于获取token的rest api要允许匿名访问
                .antMatchers("/auth/**").permitAll()
                .anyRequest().authenticated();
        //禁用http缓存
        http.headers().cacheControl().disable();
        http.addFilterBefore(jwtAuthenticationTokenFilter, UsernamePasswordAuthenticationFilter.class);
    }

@Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
                // 设置UserDetailsService
                .userDetailsService(this.userDetailsService)
                // 使用BCrypt进行密码的hash
                .passwordEncoder(passwordEncoder());
    }

// 装载BCrypt密码编码器
    @Bean
    public PasswordEncoder passwordEncoder() {

return new BCryptPasswordEncoder();
    }

@Bean(name = BeanIds.AUTHENTICATION_MANAGER)
    @Override
    public AuthenticationManager authenticationManagerBean() throws Exception {
        return super.authenticationManagerBean();
    }
}

```

#### 3.JWT(Json Web Token),基于token访问，项目安全稳定

**获取token&刷新token**

```

/**
 * @Descirption
 * @Author Jason
 * @Date 2019/11/30/
 */
@RestController
@Slf4j
public class AuthController {
    @Value("${jwt.header}")
    private String tokenHeader;

@Autowired
    private AuthService authService;

@Autowired
    private AuthenticationManager authenticationManager;
    /**
     * 获取token
     * @param authenticationRequest
     * @return
     * @throws AuthenticationException
     */

@ApiOperation("授权获取token")
    @RequestMapping(value = "/auth", method = RequestMethod.POST)
    public ResponseData createAuthenticationToken(
            @RequestBody JwtAuthenticationRequest authenticationRequest) throws AuthenticationException {
        try {
            String token = authService.login(authenticationManager,authenticationRequest.getUsername(), authenticationRequest.getPassword());
            // Return the token
            return new ResponseData(ResponseCodeEnum.SUCCESS,token);
        } catch (Exception e) {
            if(!(e instanceof AuthenticationException)){// 用户名密码验证错误
                log.error("获取token出错",e);
                return new ResponseData(ResponseCodeEnum.ERROR);
            }
        }

return new ResponseData(ResponseCodeEnum.USERNAME_OR_PASSWORD_NOT_TRUE);
    }

/**
     * 刷新token
     * @param request
     * @return
     * @throws AuthenticationException
     */
    @ApiOperation("刷新token")
    @NoLog
    @RequestMapping(value = "/refresh", method = RequestMethod.POST)
    public ResponseData refreshAndGetAuthenticationToken(
            HttpServletRequest request) throws AuthenticationException{
        try {
            String token = request.getHeader(tokenHeader);
            String refreshedToken = authService.refresh(token);
            if(refreshedToken == null) {
                return new ResponseData(ResponseCodeEnum.FAILURE);
            } else {
                return new ResponseData(ResponseCodeEnum.SUCCESS,refreshedToken);
            }
        } catch (Exception e) {
            log.error("刷新token出错",e);
        }
        return new ResponseData(ResponseCodeEnum.ERROR);
    }

}

```

##### token校验

```

/**
 * @Descirption jwt过滤器
 * @Author Jason
 * @Date 2019/11/30/
 */
@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {

@Autowired
    @Qualifier("jwtUserDetailsServiceImpl")
    private UserDetailsService userDetailsService;

@Autowired
    private JwtTokenUtil jwtTokenUtil;

@Value("${jwt.header}")
    private String tokenHeader;

@Override
    protected void doFilterInternal(
            HttpServletRequest request,
            HttpServletResponse response,
            FilterChain chain) throws ServletException, IOException {
        String authHeader = request.getHeader(this.tokenHeader);
        if (Strings.isNotBlank(authHeader)) {
            String username = jwtTokenUtil.getUsernameFromToken(authHeader);

logger.info("checking authentication " + username);

if (username != null && SecurityContextHolder.getContext().getAuthentication() == null) {

UserDetails userDetails = this.userDetailsService.loadUserByUsername(username);

if (jwtTokenUtil.validateToken(authHeader, userDetails)) {
                    UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(
                            userDetails, null, userDetails.getAuthorities());
                    authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(
                            request));
                    logger.info("authenticated user " + username + ", setting security context");
                    SecurityContextHolder.getContext().setAuthentication(authentication);
                }
            }
        }

chain.doFilter(request, response);
    }
}

```

#### 4.集成Redis

```

/**
 * 修改RedisTemplate的序列化方式
 * @param redisConnectionFactory
 * @return
 */
@Bean
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
    redisTemplate.setConnectionFactory(redisConnectionFactory);

// 使用Jackson2JsonRedisSerialize 替换默认序列化
    Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

// 设置value的序列化规则和 key的序列化规则
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    redisTemplate.setKeySerializer(new StringRedisSerializer());
    redisTemplate.afterPropertiesSet();
    return redisTemplate;
}
```
#### 5.集成Swagger2
```
/**
 * Created by Jason on 2019/12/1.
 */
@Configuration
@EnableSwagger2
public class SwaggerApp {
    @Bean
    public Docket createRestApi() {
        // swagger 增加请求头 token校验
        ParameterBuilder ticketPar = new ParameterBuilder();
        List<Parameter> pars = new ArrayList<Parameter>();
        ticketPar.name("Authorization").description("user token")
                .modelRef(new ModelRef("String")).parameterType("header")
                .required(false).build(); //header中的ticket参数非必填，传空也可以
        pars.add(ticketPar.build());      //根据每个方法名也知道当前方法在设置什么参数

return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //为当前包路径
                .apis(RequestHandlerSelectors.basePackage("com.sskjdata.cg.controller"))
                .paths(PathSelectors.any())
                .build()
                // 添加请求头等
                .globalOperationParameters(pars);
    }
    //构建 api文档的详细信息函数,注意这里的注解引用的是哪个
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                //页面标题
                .title("xxx科技 统一官方平台API")
                //版本号
                .version("1.0")
                //描述
                .description("API 请遵循Rest API风格!")
                .build();
    }
}

```

访问：http://localhost:项目启动的端口/swagger-ui.html
效果图：

![](/contentImages/image/20191217/WCWYRpFUx7mQ8Sk2IUp.png)

#### 6.全局异常处理

```
/**
 * @Descirption 所有xx选品自定义异常的父类
 * @Author Jason
 * @Date 2018/11/30/
 */
public class IntelligentException extends RuntimeException{

private ResponseCodeEnum responseCodeEnum;

public ResponseCodeEnum getResponseCodeEnum() {
        return responseCodeEnum;
    }

public void setResponseCodeEnum(ResponseCodeEnum responseCodeEnum) {
        this.responseCodeEnum = responseCodeEnum;
    }

private static final long serialVersionUID = -6689513086091556179L;

public IntelligentException() {
        this(ResponseCodeEnum.ERROR);
    }

public IntelligentException(ResponseCodeEnum responseCodeEnum) {
        super(responseCodeEnum.getMsg());
        this.responseCodeEnum = responseCodeEnum;
    }

public IntelligentException(ResponseCodeEnum responseCodeEnum, String msg) {
        super(msg);
        this.responseCodeEnum = responseCodeEnum;
    }

public IntelligentException(String message) {
        super(message);
    }

public IntelligentException(String message, Throwable cause) {
        super(message, cause);
    }

public IntelligentException(Throwable cause) {
        super(cause);
    }

public IntelligentException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
    }
}
```

#### 7.日志处理
```
logging:
  level:
      root: info
      com:
           sskjdata:
                   cg:
                      dao: debug
  file: logs/spring.log
```

#### 8.逆向工程：
先创建表，然后在这里配置表信息。然后用

![](/contentImages/image/20191217/9W4JYWHlZN7e1bsz4uA.png)

#### 9.打包部署：
clean install 可以打成一个jar包，上传到服务器jar命令启动即可

![](/contentImages/image/20191217/AVf756RHjM1ojyvTFRB.png)

脚本化部署

![](/contentImages/image/20191217/YH7chrHyNS89BNgZ9IG.png)

创建一个bin目录，存放启动管理脚本

![](/contentImages/image/20191217/lZgH4cctc6B0I45CnWp.png)

启动：start.sh，关闭：stop
#### 10：个性化定制启动banner

![](/contentImages/image/20191217/8uoobG6eGVq15Eo6EuY.png)

###  二、项目运行效果（部分页面截图）

![](/contentImages/image/20191217/eFRBPvjFrrDmwobAmoU.png)

### 三、项目部署
详细见第一步，第8，9点
### 四、项目说明
- 运行前，先配置好mysql服务
- idea 下载lombok插件
![](/contentImages/image/20191217/ObhGfEiE2oOouQCbDLL.png)

- 然后将sql文件导入到mysql当中，可以看到以下表
![](/contentImages/image/20191217/exLG5XGalWy6kAmiafH.png)
- 最后启动
![](/contentImages/image/20191217/CKFu6wSR5BMthKU51P3.png)

**本demo是一个实际生产的项目框架。可以简单方便的进行移植，扩展。同时也可进行多人协作开发，数据库版本同步。当构建自己的项目时，只需要进行简单的修改配置即可。如有问题，可联系作者！**

本实例支付的费用只是购买源码的费用，如有疑问欢迎在文末留言交流，如需作者在线代码指导、定制等，在作者开启付费服务后，可以点击“购买服务”进行实时联系，请知悉，谢谢

感谢

手机上随时阅读、收藏该文章？请扫下方二维码

超全面SpringBoot实战企业项目框架搭建

概述

详细

相似例子推荐

评论

作者

评分详细

作者例子