springboot开发总结
springboot开发总结
- 1.springboot数据校验
- 2.拦截器
- 3.过滤器
- 4.springboot使用@Scheduled定时任务
- 5.SpringBoot整合MybatisPlus
- 6.springboot整合freemarker
- 7.springboot整合kafka
- 8.springboot邮件发送
- 9.springboot整合redis
- 10.springboot整合mongodb
- 11.SpringBoot整合Swagger
- 12.未完待续。。。
1.springboot数据校验
添加依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-validation</artifactId>
</dependency>
构建需要校验的实体类：
@AllArgsConstructor
@NoArgsConstructor
@Accessors
@Data
public class User {
@NotNull(message = "用户id不能为空")
private Integer id;
@NotBlank(message = "姓名不能为空")
@Length(min = 2, max = 15, message = "姓名长度为2-15位。")
private String name;
@Range(min = 0, max = 100, message = "年龄范围应该在0-100内。")
private Integer age;
@Email(message = "邮箱格式错误")
private String email;
@Pattern(regexp = "^1(3|4|5|7|8)\\d{9}$",message = "手机号码格式错误")
@NotBlank(message = "手机号码不能为空")
private String phone;
}
Controller的请求参数上添加@Valid 注解开启验证
@RestController
@Slf4j
public class UserController {
@PostMapping("/user")
public String Validate(@RequestBody @Valid User user){
log.info("The user's information is {}", user);
return "success";
}
}
2.拦截器
编写拦截器实现类，实现HandlerInterceptor接口，在方法内实现自己的业务逻辑代码
package com.wyu.tt12validation.common.interceptor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Slf4j
public class AdminInterceptor implements HandlerInterceptor {
/**
* 在请求处理之前进行调用（Controller方法调用之前）
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
//如果设置为false时，被请求时，拦截器执行到此处将不会继续操作
//如果设置为true时，请求将会继续执行后面的操作
log.info("请求处理之前进行调用");
return true;
}
/**
* 请求处理之后进行调用，Controller方法调用之后
*/
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) {
log.info("请求处理之后进行调用");
}
/**
* 在整个请求结束之后被调用，主要是用于进行资源清理工作
*/
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
log.info("请求结束之后进行调用");
}
}
配置拦截器类并实现WebMvcConfigurer类，并重写其中的方法
@Configuration
public class MyInterceptorConfig implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
//注册TestInterceptor拦截器
InterceptorRegistration registration = registry.addInterceptor(new AdminInterceptor());
registration.addPathPatterns("/**"); //所有路径都被拦截
registration.excludePathPatterns( //添加不拦截路径
"/**/*.html", //html静态资源
"/**/*.css" //css静态资源
);
}
}
执行效果：
3.过滤器
1.拦截器与过滤器的区别
- Filter是依赖于Servlet容器，而拦截器则是独立存在的，可以在任何情况下使用
- Filter的执行由Servlet容器回调完成，而拦截器通常通过动态代理的方式来执行
- Filter的生命周期由Servlet容器管理，而拦截器则可以通过IoC容器来管理
2.编写过滤器类：
public class LogFilter implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
System.out.println("过滤器初始化----------》");
}
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse,
FilterChain filterChain) throws IOException, ServletException {
long start = System.currentTimeMillis();
filterChain.doFilter(servletRequest,servletResponse);
System.out.println("完成请求所需时间："+(System.currentTimeMillis()-start));
}
@Override
public void destroy() {
System.out.println("过滤器销毁----------》");
}
}
3.配置过滤器类：
@Configuration
public class FilterConfig {
@Bean
public FilterRegistrationBean registFilter() {
FilterRegistrationBean registration = new FilterRegistrationBean();
registration.setFilter(new LogFilter());
registration.addUrlPatterns("/*");
registration.setName("LogFilter");
registration.setOrder(1); //配置多个过滤器时，执行的优先级
return registration;
}
}
4.springboot使用@Scheduled定时任务
1.cron表达式字符含义说明
cron表达式：* * * * * *，其实就是一个字符串，
字符串以5或6个空格隔开，分为6或7个域，每一个域代表一个含义，其中常用为六个域。
corn从左到右（用空格隔开）分别是：秒 分 小时 月份中的日期 月份 星期中的日期 年份
| 字段 | 允许值 | 允许的特殊字符 |
|---|---|---|
| 秒（Seconds） | 0~59的整数 | , - * / 四个字符 |
| 分（Minutes） | 0~59的整数 | , - * / 四个字符 |
| 小时（Hours） | 0~23的整数 | , - * / 四个字符 |
| 日期（DayofMonth） | 1~31的整数（但是你需要考虑你月的天数） | ,- * ? / L W C 八个字符 |
| 月份（Month） | 1~12的整数或者 JAN-DEC | , - * / 四个字符 |
| 星期（DayofWeek） | 1~7的整数或者 SUN-SAT （1=SUN） | , - * ? / L C # 八个字符 |
| 年(可选，不常用)（Year） | 1970~2099 | , - * / 四个字符 |
corn表达式示范
- 每隔5秒执行一次：*/5 * * * * ?
- 每隔1分钟执行一次：0 */1 * * * ?
- 每小时的20分执行一次：0 20 * * * ?
- 每天的两点35分执行一次：0 35 2 * * ?
- 每月的1日的凌晨2点调整任务：0 0 2 1 * ? *
- 每天上午10点，下午2点，4点 执行一次：0 0 10,14,16 * * ?
- 每周星期天凌晨1点实行一次 ：0 0 1 ? * L
2.@Scheduled注解说明：
@Scheduled(
initialDelay = 5000, //第一次延迟多长时间后再执行
initialDelayString = "5000", //第一次延迟5秒后执行，值为String类型
fixedDelay = 5000, //上一次执行完毕时间点之后多长时间再执行
fixedDelayString = "5000", //上一次执行完毕时间点之后5秒再执行，值为String类型
fixedRate = 5000, //上一次开始执行时间点之后多长时间再执行
fixedRateString = "5000", //上一次开始执行时间点之后5s再执行，值为String类型
cron = "", //cron的表达式
zone = "" //时区，cron表达式会基于该时区解析。默认是一个空字符串，即取服务器所在地的时区
)
3.springboot工程中使用
在springboot的主类上，加上注解@EnableScheduling
@SpringBootApplication
@EnableScheduling
public class MybatisplusdemoApplication {
public static void main(String[] args) {
SpringApplication.run(MybatisplusdemoApplication.class, args);
}
}
编写测试类
package com.wyu.mybatisplusdemo.article.controller;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.scheduling.annotation.Scheduled;
import java.text.SimpleDateFormat;
import java.util.Date;
@Component
public class Schedule {
Logger log = LoggerFactory.getLogger(Schedule.class);
//cron表达式：每隔5秒执行一次
@Scheduled(cron = "0/5 * * * * *")
public void scheduled(){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("hh点mm分ss秒");
// 将date日期解析为字符串
String date = simpleDateFormat.format(new Date());
log.info("当前时间：" + date);
}
}
执行结果：
5.SpringBoot整合MybatisPlus
1.引入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid-spring-boot-starter</artifactId>
<version>1.1.9</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.0.1</version>
</dependency>
2.添加配置：
server:
port: 8090
spring:
#------------------------MySql-----------------------------
datasource:
url: jdbc:mysql://127.0.0.1:3306/demo?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
username: root
password: 123456
driver-class-name: com.mysql.jdbc.Driver
type: com.alibaba.druid.pool.DruidDataSource
mybatis-plus:
mapper-locations: classpath:mapper/*/*Mapper.xml
type-aliases-package: com.wyu.tt13mybatisplus.*.model
global-config:
refresh-mapper: true
3.数据库表设计：
CREATE TABLE `article` (
`article_id` bigint(20) NOT NULL AUTO_INCREMENT,
`title` varchar(128) DEFAULT NULL COMMENT '文章标题',
`content` longtext COMMENT '正文内容',
PRIMARY KEY (`article_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1000 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='文章表';
4.实体类：
@AllArgsConstructor
@NoArgsConstructor
@Accessors
@Data
@TableName("article")
public class Article implements Serializable {
private static final long serialVersionUID = 1L;
//标识主键策略
@TableId
private Long articleId;
private String title;
private String content;
}
5.ArticleDao接口，另外也可以在这里自定义mybatis接口写sql
@Mapper
public interface ArticleDao extends BaseMapper<Article> {
}
6.ArticleService ：
@Service
public class ArticleService {
@Autowired
private ArticleDao articleDao;
/**
* 1.新增 , insert方法
* @param article
* @return
*/
public boolean save(Article article){
return articleDao.insert(article) > 0;
}
/**
* 2.通过QueryWrapper查询数量
*/
public Integer selectArticleCount(){
return articleDao.selectCount(new QueryWrapper<Article>().eq("title","测试"));
}
/**
* 3.通过selectMaps查询list<Map<String, Object>>
*/
public List<Map<String, Object>> selectArticleMaps(){
QueryWrapper<Article> queryWrapper = new QueryWrapper<>();
queryWrapper.eq("title", "测试");
List<Map<String, Object>> list = articleDao.selectMaps(queryWrapper);
return list;
}
/**
* 4.通过QueryWrapper查询list<Object>
*/
public List<Object> selectObjs()
{
List<Object> list = articleDao.selectObjs(new QueryWrapper<Article>().eq("title", "测试"));
return list;
}
/**
* 5.分页查询,笔者个人还是比较喜欢使用pagehelper来分页，毕竟比较简单
*/
public IPage<Article> selectPage()
{
QueryWrapper queryWrapper = new QueryWrapper<Article>().eq("title", "测试");
int count = articleDao.selectCount(queryWrapper);
IPage<Article> page = new Page(1,2);
IPage<Article> list = articleDao.selectPage(page, queryWrapper);
System.out.println("返回数据："+ list.getRecords());
System.out.println("总条数："+list.getTotal() + "当前页码："+list.getCurrent()+ "总页码："+list.getPages() + "每页显示条数："+list.getSize());
System.out.println("返回的数据："+page.getRecords());
return list;
}
/**
* 6，删除，根据articleId来删除
*/
public boolean delete(Long articleId)
{
return articleDao.deleteById(articleId) > 0;
}
/**
* 7，删除，根据QueryWrapper删除
*/
public boolean deleteByQueryWrapper()
{
return articleDao.delete(new QueryWrapper<Article>().eq("title", "测试")) > 0;
}
/**
* 8, 批量删除，把多个id存放到list中，再批量删除，其实很少会用到
*/
public boolean deleteBatchIds(List<Long> articleIdList)
{
return articleDao.deleteBatchIds(articleIdList) > 0;
}
/**
* 9，修改 封装方法中做了非空校验，如果该字段为null,则不进行更新
*/
public boolean updateById(Article article) {
return articleDao.updateById(article) > 0;
}
}
7.controller：
@RestController
public class ArticleController {
@Autowired
private ArticleService articleService;
@RequestMapping("/selectArticleCount")
public Integer selectArticleCount(){
return articleService.selectArticleCount();
}
@RequestMapping("/selectPage")
public String selectPage(){
return articleService.selectPage().toString();
}
}
6.springboot整合freemarker
1.引入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>
2.添加配置：
#------------------------freemarker-----------------------------
spring:
freemarker:
cache: false
suffix: .ftl
template-loader-path: classpath:/templates
content-type: text/html; charset=utf-8
settings:
number_format: 0 #数字格式，比较大的数字会带有逗号，如1,000
4.Freemarker表达式使用：
- 获取元素值：
<#if (msg)!="">
${msg}
</#if>
- 循环输出list，先判断list是否为空：
<#if students ?? && students ?size gt 0>
<#list students as student>
${student.name}
${student.age}
</#list>
</#if>
- 逻辑判断：
<#if type == 1>
type=1
<#elseif type == 2>
type=2
</#if>
- 格式化输出时间：
${createTime?string('yyyy-MM-dd hh:mm:ss')}
- include标签，引入其他页面
<#include "right.ftl">
7.springboot整合kafka
1.引入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.kafka</groupId>
<artifactId>spring-kafka</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
2.添加配置：
spring:
kafka: # 指定kafka 代理地址，可以多个
bootstrap-servers: 192.168.211.137:9092,192.168.211.139:9092,192.168.211.140:9092
template: # 指定默认topic id
default-topic: producer
listener: # 指定listener 容器中的线程数，用于提高并发量
concurrency: 5
consumer:
group-id: myGroup # 指定默认消费者group id
client-id: 200
max-poll-records: 200
auto-offset-reset: earliest # 最早未被消费的offset
producer:
batch-size: 1000 # 每次批量发送消息的数量
retries: 3
client-id: 200
3.生产者
@Slf4j
@Component
public class KafkaProducer {
@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
@Autowired
private ObjectMapper objectMapper;
public void send(String topic, Object body) {
Message<String> message = new Message<>();
message.setId(System.currentTimeMillis());
message.setMessage(body.toString());
message.setTime(new Date());
String content = null;
try {
content = objectMapper.writeValueAsString(message);
} catch (JsonProcessingException e) {
e.printStackTrace();
}
kafkaTemplate.send(topic, content);
log.info("send {} to {} success!", message, topic);
System.out.println("send "+ message +" to "+ topic +" success!");
}
}
4.消费者
@Slf4j
@Component
public class KafkaConsumer {
/**
* 有消息就读取,读取消息topic，offset，key，value等信息
*/
@KafkaListener(topics = {"kafka1"})
public void listen(ConsumerRecord<?, ?> record) {
Optional<?> kafkaMessage = Optional.ofNullable(record.value());
if (kafkaMessage.isPresent()) {
Object message = kafkaMessage.get();
log.info("详细消息读取-------------------->");
log.info("message:{} + record:{}", message, record);
}
}
/**
* 有消息就读取,批量读取消息
*/
@KafkaListener(topics = "kafka1")
public void onMessage(List<String> crs) {
for(String str : crs){
log.info("批量读取-------------------->");
log.info("kafka1:" + str);
}
}
/**
* 有消息就读取message
*/
@KafkaListener(topics = {"kafka1"})
public void receiveMessage(String message){
log.info("读取message-------------------->");
log.info("kafka1:" + message);
}
}
5.Controller：
@Slf4j
@RestController
public class KafkaController {
@Autowired
private KafkaProducer kafkaProducer;
@GetMapping("/kafka/{topic}")
public String send(@PathVariable("topic") String topic, @RequestParam String message) {
kafkaProducer.send(topic, message);
return "success";
}
}
8.springboot邮件发送
1.添加依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-mail</artifactId>
</dependency>
2.添加配置：
spring:
mail:
host: smtp.163.com
username: ****@163.com #自己的邮箱账号
password: ******* #这个不是登录密码而是163授权登录的密码
default-encoding: UTF-8
获取163授权的密码，到163的网页端，把以下两个开关打开
3.功能测试
@Autowired
private JavaMailSender javaMailSender;
//发送普通文本邮件
@RequestMapping(value = "/sendMail")
public String sendMail(Model model) {
SimpleMailMessage message = new SimpleMailMessage();
message.setFrom("654321***@163.com"); //发送者
message.setTo("123456***@qq.com"); //接受者
message.setCc("654321***@163.com"); //抄送，填发送者的邮箱即可
message.setSubject("今天天气真好"); //主题
message.setText("你好你好你好！"); //内容
try {
javaMailSender.send(message);
System.out.println("简单邮件已经发送");
} catch (Exception e) {
System.out.println("发送简单邮件时发生异常！"+e.toString());
}
model.addAttribute("msg", "");
return "login";
}
//也可以发送html形式的邮件
@RequestMapping("/sendHtmlMail")
public void sendHtmlMail() {
String content="\n" +
"\n" +
" 你好你好你好!
\n" +
"\n" +
"";
MimeMessage message = javaMailSender.createMimeMessage();
try {
MimeMessageHelper messageHelper = new MimeMessageHelper(message, true);
messageHelper.setFrom("654321***@163.com");
messageHelper.setTo("123456***@qq.com");
messageHelper.setSubject("今天天气真好");
messageHelper.setText(content, true);
javaMailSender.send(message);
System.out.println("邮件成功发送");
} catch (MessagingException e) {
System.out.println("发送邮件时发生异常！"+e.toString());
}
}
4.执行效果：
9.springboot整合redis
1.引入依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2.添加配置：
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
#连接池最大连接数
spring.redis.jedis.pool.max-active=8
#连接池最大阻塞等待时间 默认 -1 表示没有限制
spring.redis.jedis.pool.max-wait=-1ms
#连接池最大空闲连接数
spring.redis.jedis.pool.max-idle=8
#连接池最小空闲连接数
spring.redis.jedis.pool.min-idle=0
3.常用方法：
StringRedisTemplate：
//先引入StringRedisTemplate
@Autowired
private StringRedisTemplate stringRedisTemplate;
//向redis里存入数据和设置缓存时间
stringRedisTemplate.opsForValue().set("redis", "100", 60 * 10, TimeUnit.SECONDS);
//val做-1操作
stringRedisTemplate.boundValueOps("redis").increment(-1);
//根据key获取缓存中的val
stringRedisTemplate.opsForValue().get("redis")
//val +1
stringRedisTemplate.boundValueOps("redis").increment(1);
//根据key获取过期时间
stringRedisTemplate.getExpire("redis");
//根据key获取过期时间并换算成指定单位
stringRedisTemplate.getExpire("redis",TimeUnit.SECONDS);
//根据key删除缓存
stringRedisTemplate.delete("redis");
//检查key是否存在，返回boolean值
stringRedisTemplate.hasKey("redis");
//向指定key中存放set集合
stringRedisTemplate.opsForSet().add("redis", "1","2","3");
//设置过期时间
stringRedisTemplate.expire("redis",1000 , TimeUnit.MILLISECONDS);
//根据key查看集合中是否存在指定数据
stringRedisTemplate.opsForSet().isMember("redis", "1");
//根据key获取set集合
stringRedisTemplate.opsForSet().members("redis");
//验证有效时间
Long expire = stringRedisTemplate.boundHashOps("redis").getExpire();
System.out.println("redis有效时间："+expire+"秒");
10.springboot整合mongodb
1.添加依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
2.添加如下配置：
itblog表示MongoDB中的itblog库
spring:
data:
mongodb:
uri: "mongodb://106.55.55.259:27017/itblog"
3.编写实体类
@Data
@Document("user")
public class User {
@Id
private String id;
@Field("name")
private String name;
@Field("password")
private String password;
@Field("address")
private String address;
@Field("create_time")
private Date createTime;
}
4.编写dao
public interface UserDao {
List<User> findAll();
User findById(String id);
User save(User user);
User insert(User user);
void deleteById(String id);
}
5.编写service
@Service
public class UserService implements UserDao {
@Autowired
private MongoTemplate template;
@Override
public List<User> findAll() {
return template.findAll(User.class);
}
@Override
public User findById(String id) {
return template.findById(id,User.class);
}
@Override
public User save(User user) {
return template.save(user);
}
@Override
public User insert(User user) {
return template.insert(user);
}
@Override
public void deleteById(String id) {
Query query = new Query();
query.addCriteria(Criteria.where("id").is(id));
template.remove(query, User.class);
}
}
6.编写controller
@RestController
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("")
public List<User> getAllUsers() {
return userService.findAll();
}
@GetMapping("/{id}")
public User getByUserId(@PathVariable String userId) {
return userService.findById(userId);
}
@PostMapping("")
public User addNewUser(@RequestBody User user) {
if (user.getId() == null) {
return userService.insert(user);
}
return userService.save(user);
}
@DeleteMapping("/{id}")
public String delete(@PathVariable String id) {
User user = new User();
user.setId(id);
userService.deleteById(id);
return "deleted: " + id;
}
@PutMapping("")
public User update(@RequestBody User user) {
return userService.save(user);
}
}
11.SpringBoot整合Swagger
1.引入依赖：
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
2.swagger配置类：
@Configuration
@EnableSwagger2
public class SwaggerConfig {
/**
* swagger通过配置会生成文档，包括接口名、请求方法、参数、返回信息等
*/
@Bean
public Docket createRestApi() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.wyu.tt08mongo"))
.paths(PathSelectors.any())
.build();
}
private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("基于Swagger构建的Rest API文档")
.description("MongoDB 在线文档！")
.termsOfServiceUrl("https://blog.csdn.net/weixin_39025362/article/details/106938581")
.version("1.0")
.build();
}
}
3.执行结果：
