springboot组件速查

使用须知

本速搭为作者经验所成，若有问题请联系修改
该速搭不适用于新手，建议收藏，未来掌握springboot后可以使用

pom.xml配置

pom.xml启动器

    
        
        
            org.springframework.boot
            spring-boot-starter
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
        
            org.springframework.boot
            spring-boot-devtools
            true
        
        
        
            org.springframework.boot
            spring-boot-starter-thymeleaf
        
        
        
            mysql
            mysql-connector-java
            runtime
        
        
        
            org.projectlombok
            lombok
            true
        
        
        
            junit
            junit
        
        
        
            org.springframework.boot
            spring-boot-starter-validation
        
    

pom.xml构建排除项

    
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            org.projectlombok
                            lombok
                        
                    
                
            
        
    

yml设置

# *** 解除注释为选则使用 ***
spring:
  # 设置数据库
  datasource:
    # *** 根据mysql版本调整 ***
    driver-class-name: com.mysql.cj.jdbc.Driver
    # *** 【必填】修改数据库（xgk2023） ***
    url: jdbc:mysql://localhost:3306/Name?serverTimezone=GMT%2B8
    # *** 【必填】修改用户名账号密码 ***
    username: root
    password: 123456
  thymeleaf:
    cache: false

  # ***【选填】使templates里的html能访问到static里的静态资源 ***
  # templates里的html访问不到static里的静态资源时添加 
#  mvc:
#    static-path-pattern: /static
        boolean serviceNameStartWithI = false;//user -> UserService 设置成true: user -> IUserService
        generateByTables(serviceNameStartWithI, packageName, "user"); 
    }

    private void generateByTables(boolean serviceNameStartWithI, String packageName, String... tableNames) {
        GlobalConfig config = new GlobalConfig();
        String dbUrl = "jdbc:mysql://localhost:3306/xgk2023";       
        DataSourceConfig dataSourceConfig = new DataSourceConfig();
        dataSourceConfig.setDbType(DbType.MYSQL)
                .setUrl(dbUrl)
                .setUsername("root")    
                .setPassword("123456")  
                .setDriverName("com.mysql.jdbc.Driver");
        StrategyConfig strategyConfig = new StrategyConfig();
        strategyConfig
                .setCapitalMode(true)
                .setEntityLombokModel(true) // 实体是否为lombok模型（默认 false)
                .setNaming(NamingStrategy.underline_to_camel)	// 命名法转换
                .setInclude(tableNames);
        config.setActiveRecord(false)
                .setAuthor("hlt")
                .setOutputDir("D://Projects//IDEA//springboot-01-helloworld//src//main//java") 
                .setFileOverride(true);
        if (!serviceNameStartWithI) {
            config.setServiceName("%sService");
        }
        new AutoGenerator().setGlobalConfig(config)
                .setDataSource(dataSourceConfig)
                .setStrategy(strategyConfig)
                .setPackageInfo(
                        new PackageConfig()		
                                .setParent(packageName)
                                .setController("controller")
                                .setEntity("entity")
                ).execute();
    }

    private void generateByTables(String packageName, String... tableNames) {
        generateByTables(true, packageName, tableNames);
    }
}

分页组件

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@MapperScan("com.sdjzu.xgk.mapper")
@EnableTransactionManagement
@Configuration
public class MybatisPlusConfig {
    
    
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
    
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        paginationInterceptor.setOverflow(false);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        paginationInterceptor.setLimit(500);
        // 开启 count 的 join 优化,只针对部分 left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }
}

分页组件使用方法

Page page = new Page<>(current, 10);	
// 第一个参数 页码   第二个参数  每页数量
xgkMapper.selectPage(page, null);
// 第一个参数 分页器   第二个参数  查询条件
List xgks = page.getRecords();

实体与数据库关系绑定设置的注解

// 设置实体类对应的表名
@TableName("表名")

// 将属性对应的字段指定为主键
// value 用于指定主键的字段
// type 设置主键生成策略  默认雪花算法 案例中使用的自增
@TableId(value="字段名",type="IdType.AUTO")		

// 指定属性所对应的字段名
@TableField("字段名")

// 指定属性对应的字段为逻辑删除字段
@TableLogic

SpringSecurity安全

注意：

1. Security配置中未定义的组件可先注释掉，不影响正常使用。
2. Security配置中需要的组件在本文章中都能找到
   

引入依赖

  org.springframework.boot
  spring-boot-starter-security

数据库时区设置

url: jdbc:mysql://localhost:3306/xgk2023?serverTimezone=GMT%2B8
# ?serverTimezone=GMT%2B8 注意添加这一部分

Security配置组件

import com.sdjzu.xgk.security.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

@Configuration
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Autowired
    LoginFailureHandler loginFailureHandler; 	

    @Autowired
    LoginSuccessHandler loginSuccessHandler;	

    @Autowired
    CaptchaFilter captchaFilter;	

    @Autowired
    JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint; 

    @Autowired
    JwtAccessDeniedHandler jwtAccessDeniedHandler;	

    @Autowired
    UserDetailServiceImpl userDetailService;	
    
        private static final String[] URL_WHITELIST = {
            
            //  "
                .failureHandler(loginFailureHandler) 
                .loginPage("/xxx")          		 
                .loginProcessingUrl("/login")   	 
                .defaultSuccessUrl("/xxx")   		 
                .permitAll()
            // 注销配置
                .and()			// .and() 相当于 http
                .logout()
                .logoutUrl("/logout")  		
                .logoutSuccessUrl("/xxx") 	
                .permitAll();
            // 禁用session
                .and()
                .sessionManagement()
                .sessionCreationPolicy(SessionCreationPolicy.STATELESS)
            // 配置拦截规则
                .and()
                .authorizeRequests()
                .antMatchers(URL_WHITELIST).permitAll()
                .anyRequest().authenticated()	// 允许任何请求类型
                
            // 配置异常处理器
                .and()
                .exceptionHandling()
                .authenticationEntryPoint(jwtAuthenticationEntryPoint)
                .accessDeniedHandler(jwtAccessDeniedHandler)
            // 配置过滤器
                .and()
                .addFilter(jwtAuthenticationFilter())	// 添加jwt身份验证过滤器
                // 在用户名密码认证过滤器前添加验证码过滤器
                .addFilterBefore(captchaFilter, UsernamePasswordAuthenticationFilter.class)
                
    }
    
    // 配置自定义的登录验证器
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.userDetailsService(userDetailService);
    }
}

登录处理组件

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.sdjzu.xgk.entity.Users;
import com.sdjzu.xgk.mapper.UsersMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.AuthorityUtils;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserDetailServiceImpl implements UserDetailsService {

	@Autowired
	UsersMapper usersMapper;

	@Override
	public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

		QueryWrapper wrapper = new QueryWrapper<>();
		wrapper.eq("username", username);
		Users user = usersMapper.selectOne(wrapper);
		if (user == null) {
			throw new UsernameNotFoundException("用户名或密码不正确");
		}
		List auths = AuthorityUtils
				.commaSeparatedStringToAuthorityList(
						
						user.getRoot() + "," + user.getRole()
				);
		return new User(
				user.getUsername(),  // 账号
				new BCryptPasswordEncoder().encode(user.getPassword()), // 密码
				auths  // 传入的角色  固定
		);
	}

	public List getUserAuthority(String username){
		QueryWrapper wrapper = new QueryWrapper<>();
		wrapper.eq("username", username);
		Users user = usersMapper.selectOne(wrapper);
		if (user == null) {
			throw new UsernameNotFoundException("用户名或密码不正确");
		}
		return AuthorityUtils
				.commaSeparatedStringToAuthorityList(
						user.getRoot() + "," + user.getRole()
				);
	}

}

登录失败处理组件

import cn.hutool.json.JSONUtil;

import com.sdjzu.xgk.common.lang.Result;
import org.springframework.security.core.AuthenticationException;
import org.springframework.security.web.authentication.AuthenticationFailureHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class LoginFailureHandler implements AuthenticationFailureHandler {

	@Override
	public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {

		response.setContentType("application/json;charset=UTF-8");
		ServletOutputStream outputStream = response.getOutputStream();

		Result result = Result.fail("用户名或密码错误");
        result.setMsg(exception.getMessage());
        result.setCode(201);
		outputStream.write(JSONUtil.toJsonStr(result).getBytes("UTF-8"));

		outputStream.flush();
		outputStream.close();
	}
}

登录成功处理组件

import cn.hutool.json.JSONUtil;
import com.sdjzu.xgk.common.lang.Result;
import com.sdjzu.xgk.utils.JwtUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.web.authentication.AuthenticationSuccessHandler;
import org.springframework.stereotype.Component;

import javax.servlet.ServletException;
import javax.servlet.ServletOutputStream;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

@Component
public class LoginSuccessHandler implements AuthenticationSuccessHandler {

	@Autowired
	JwtUtils jwtUtils;

	@Override
	public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
		// 获取当前响应信息
        response.setContentType("application/json;charset=UTF-8");
		ServletOutputStream outputStream = response.getOutputStream();

		// 生成jwt，并添加到响应头中
		String jwt = jwtUtils.generateToken(authentication.getName());
		response.setHeader(jwtUtils.getHeader(), jwt);
        
        // 生成Result，并添加到响应中
		Result result = Result.succ("");
		outputStream.write(JSONUtil.toJsonStr(result).getBytes("UTF-8"));

		outputStream.flush();
		outputStream.close();
	}

}

通过注解设置权限

在接口或接口类前添加如下注解
用户具有某个角色，可以访问方法
@Secured({"ROLE_sale","ROLE_manager"}) 
使用于进入方法前的权限验证
可以将登录用户的roles/premissions参数传入到方法中
@PreAuthorize("hasRole('ROLE_管理员')")
@PreAuthorize("hasAnyAuthority('menu:system')")
使用于进入方法后的权限验证  常用于返回值
@PostAuthorize("hasAnyAuthority('menu:system')")
    以下两个注解用在上面几个注解之后
权限验证之后对数据进行过滤，留下用户名是admin1的数据
表达式中filterObject引用的方法是返回值List中的某一个元素
@PostFilter("filterObject.username == 'admin1'")
进入控制器之前对数据进行过滤
@PreFilter(value = "filterObject.id%2==0")

redis工具

引入依赖

  org.springframework.boot
  spring-boot-starter-data-redis

redis配置

import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    @Bean
    RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        jackson2JsonRedisSerializer.setObjectMapper(new ObjectMapper());

        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);

        return redisTemplate;
    }
}

redis工具类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;

    
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }

    //============================String=============================

    
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    //================================Map=================================

    
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    
    public Map hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    
    public boolean hmset(String key, Map map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public boolean hmset(String key, Map map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    //============================set=============================

    
    public Set