springBoot(1)--初步理解
在没有用SpringBoot之前，我们用spring和springMVC框架，但是你要做很多比如：
(1)配置web.xml，加载spring和spring mvc
2）配置数据库连接、配置spring事务
3）配置加载配置文件的读取，开启注解
4）配置日志文件
会比较繁琐，但是用springBoot我仅仅只需要非常少的几个配置就可以迅速方便的搭建起来一套web项目或者是构建一个微服务！
小案例
Springboot的Java配置方式是通过 @Configuration 和 @Bean 这两个注解实现的：
1、@Configuration 作用于类上，相当于一个xml配置文件;
2、@Bean 作用于方法上，相当于xml配置中的<bean>;
一.项目project
项目采用的是：maven，eclipse
项目github地址：springbootstudy1
1.pom.xml
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>cn.binron.springboot</groupId> <artifactId>binron-springboot</artifactId> <version>0.0.1-SNAPSHOT</version> <packaging>war</packaging> <dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>4.0.2.RELEASE</version> </dependency> <!-- 连接池 --> <dependency> <groupId>com.jolbox</groupId> <artifactId>bonecp-spring</artifactId> <version>0.8.0.RELEASE</version> </dependency> </dependencies> <build> <finalName>${project.artifactId}</finalName> <plugins> <!-- 资源文件拷贝插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-resources-plugin</artifactId> <configuration> <encoding>UTF-8</encoding> </configuration> </plugin> <!-- java编译插件 --> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.7</source> <target>1.7</target> <encoding>UTF-8</encoding> </configuration> </plugin> </plugins> <pluginManagement> <plugins> <!-- 配置Tomcat插件 --> <plugin> <groupId>org.apache.tomcat.maven</groupId> <artifactId>tomcat7-maven-plugin</artifactId> <version>2.2</version> </plugin> </plugins> </pluginManagement> </build> </project>
我在配置pom文件的时候，遇到麻烦就是在本地仓库找不到我的相应jar，从远处仓库下载也下载不到，后来才发现是settings.xml的问题
所以我在网上找了个settings.xml文件，直接把我的给替换掉，然后在 clean --install--update就好了。网上settings.xml文件内容。
2.User对象
public class User {
private String username;
private String password;
private Integer age;
//提供set和get方法
}
3.编写UserDAO 用于模拟与数据库的交互
我把userDao模拟成连接数据库并取得值
public class UserDAO {
public List<User> queryUserList(){
List<User> result = new ArrayList<User>();
// 模拟数据库的查询
for (int i = 0; i < 10; i++) {
User user = new User();
user.setUsername("username_" + i);
user.setPassword("password_" + i);
user.setAge(i + 1);
result.add(user);
}
return result;
}
4.编写UserService 用于实现User数据操作业务逻辑
@Service
public class UserService {
@Autowired // 注入Spring容器中的bean对象
private UserDAO userDAO;
public List<User> queryUserList() {
// 调用userDAO中的方法进行查询
return this.userDAO.queryUserList();
}
}
5. 编写SpringConfig 用于实例化Spring容器
@Configuration //通过该注解来表明该类是一个Spring的配置，相当于一个xml文件
@ComponentScan(basePackages = "cn.itcast.springboot.javaconfig") //配置扫描包
public class SpringConfig {
@Bean // 通过该注解来表明是一个Bean对象，相当于xml中的<bean>
public UserDAO getUserDAO(){
return new UserDAO(); // 直接new对象做演示
}
}
6. 编写测试方法 用于启动Spring容器
public class Main {
public static void main(String[] args) {
// 通过Java配置来实例化Spring容器
AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringConfig.class);
// 在Spring容器中获取Bean对象
UserService userService = context.getBean(UserService.class);
// 调用对象中的方法
List<User> list = userService.queryUserList();
for (User user : list) {
System.out.println(user.getUsername() + ", " + user.getPassword() + ", " + user.getPassword());
}
// 销毁该容器
context.destroy();
}
}
最后看后台数据有没有成功打印：
一、快速创建项目
springboot官网提供了工具类自动创建web应用：网址：http://start.spring.io/
官网页面
1、快速创建一个
选择web代表这是一个web项目
这样就可以吧项目放到eclipse或者idea中进行运行了。
这里需要注意几点：
1.springboot2X，所需要mevan是3.0+，JDK是1.8+
2.在做项目开发的时候，主入口Application类（带有注解@SpringBootApplication），要放在所有包之上。
二、初解jackson
jackson是springboot自带的json框架
jackson常用标签
（1）指定字段不返回：@JsonIgnore
（2）指定日期格式：@JsonFormat(pattern="yyyy-MM-dd hh:mm:ss",locale="zh",timezone="GMT+8")
（3）空字段不返回：@JsonInclude(Include.NON_NUll)
（4）指定别名：@JsonProperty
举例：
user对象
public class User {
@JsonProperty("account")
private int age;
@JsonIgnore
private String pwd;
@JsonInclude(Include.NON_NULL)
private String phone;
@JsonFormat(pattern="yyyy-MM-dd hh:mm:ss",locale="zh",timezone="GMT+8")
private Date createTime;
//提供set和get方法，tostring方法
}
Controller类中映射方法
@GetMapping("/testjackson")
public Object testjson(){
return new User(0, "密码", null, new Date());
}
效果演示 接口测试工具是postman
我们发现：
1：日期时间格式变成了指定格式
2：age属性显示在界面变成了：account
3：pwd并没有显示
4：因为phone属性为null，所以也没有显示。
目录结构，文件上传
一、目录结构
1、目录讲解
src/main/java：存放代码
src/main/resources
static: 存放静态文件，比如 css、js、image, （访问方式 http://localhost:8080/js/main.js）
templates:存放静态页面jsp,html,tpl
config:存放配置文件,application.properties
resources:
2、同个文件的加载顺序,静态资源文件
Spring Boot 默认会挨个从
META/resources > resources > static > public 里面找是否存在相应的资源，如果有则直接返回。
什么意思呢，就是比如你有个index.html文件，springboot默认放在以上文件夹是可以访问到的,而且是按照这个顺序访问。
案例：我在，resources，static ，public ，templates都放一个index.html文件，然后输入：localhost:8080,看访问的是哪个index.html
可以看出：首先访问就是resources里面的index.html
text文件默认是访问不了的，就算你的是localhost:8080/text/index.html也是访问不了的。
不过，你在application.properties配置如下，就可以访问了
spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/,classpath:/test/
二、文件上传
一、war包方式进行上传
springboot文件上传的对象是MultipartFile，它是file的子类，源自
1）静态页面直接访问：localhost:8080/index.html
注意点：
如果想要直接访问html页面，则需要把html放在springboot默认加载的文件夹下面
2）MultipartFile 对象的transferTo方法，用于文件保存（效率和操作比原先用FileOutStream方便和高效）
案例：在static文件目录下，
upload.html
<!DOCTYPE html>
<html>
<head>
<title>uploadimg.html</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
<!--涉及文件上传，这里就需要multipart/form-data-->
<form enctype="multipart/form-data" method="post" action="/upload">
文件:<input type="file" name="head_img"/>
姓名:<input type="text" name="name"/>
<input type="submit" value="上传"/>
</form>
</body>
</html>
FileController类
package com.jincou.ocontroller;
import java.io.File;
import java.io.IOException;
import java.util.UUID;
import javax.servlet.http.HttpServletRequest;
import com.jincou.model.JsonData;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.multipart.MultipartFile;
@Controller
public class FileController {
//文件放在项目的images下
private static final String filePath = "C:\\Users\\chenww\\Desktop\\springbootstudy\\springbootstudy\\src\\main\\resources\\static\\images\\";
@RequestMapping(value = "upload")
@ResponseBody
public JsonData upload(@RequestParam("head_img") MultipartFile file,HttpServletRequest request) {
//file.isEmpty(); 判断图片是否为空
//file.getSize(); 图片大小进行判断
String name = request.getParameter("name");
System.out.println("用户名："+name);
// 获取文件名
String fileName = file.getOriginalFilename();
System.out.println("上传的文件名为：" + fileName);
// 获取文件的后缀名,比如图片的jpeg,png
String suffixName = fileName.substring(fileName.lastIndexOf("."));
System.out.println("上传的后缀名为：" + suffixName);
// 文件上传后的路径
fileName = UUID.randomUUID() + suffixName;
System.out.println("转换后的名称:"+fileName);
File dest = new File(filePath + fileName);
try {
file.transferTo(dest);
//上传成功
return new JsonData(0, fileName);
} catch (IllegalStateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
//上传失败
return new JsonData(-1, "fail to save ", null);
}
}
JsonData对象，用来返回状态
package com.jincou.model;
import java.io.Serializable;
public class JsonData implements Serializable {
private static final long serialVersionUID = 1L;
//状态码,0表示成功，-1表示失败
private int code;
//结果
private Object data;
//错误描述
private String msg;
public int getCode() {
return code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
public void setCode(int code) {
this.code = code;
}
public Object getData() {
return data;
}
public void setData(Object data) {
this.data = data;
}
public JsonData(int code, Object data) {
super();
this.code = code;
this.data = data;
}
public JsonData(int code, String msg,Object data) {
super();
this.code = code;
this.msg = msg;
this.data = data;
}
}
效果：
这里面如果你想限制上传问价大小，可以在添加如下：
//文件大小配置，启动类里面配置
@Bean
public MultipartConfigElement multipartConfigElement() {
MultipartConfigFactory factory = new MultipartConfigFactory();
//单个文件最大
factory.setMaxFileSize("10240KB"); //KB,MB
/// 设置总上传数据总大小
factory.setMaxRequestSize("1024000KB");
return factory.createMultipartConfig();
}
总结：
1.其实在正式项目里，这里的文件上传地址不会是在本项目里，而是会指定一个文件服务器：
常用文件服务器：fastdfs，阿里云oss，nginx搭建一个简单的文件服务器
2.有关单个文件最大值，路径最好是配置在配置文件里，这样后期好维护。
热部署，配置文件使用
一、热加载
spring为开发者提供了一个名为spring-boot-devtools的模块来使Spring Boot应用支持热部署，提高开发者的开发效率，无需手动重启Spring Boot应用。
devtools的原理
深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为restart ClassLoader,这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间。
官方地址：https://docs.spring.io/spring-boot/docs/2.1.0.BUILD-SNAPSHOT/reference/htmlsingle/#using-boot-devtools
实现热部署，首先要引入：spring-boot-devtools.jar包
核心依赖包：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
添加依赖后，在ide里面重启应用，后续修改后马上可以生效
默认不被热部署的文件
1、/META-INF/maven, /META-INF/resources, /resources, /static, /public, or /templates
2、指定文件不进行热部署 spring.devtools.restart.exclude=static/**,public/**
在开发中，我们会思考一个问题？
如果你写一个逻辑代码，需要好几个文件，总不能你每保存一次就进行一次热部署，这里有个解决方法。
在application.properties添加手工触发重启
#指定某些文件不进行监听，即不会进行热加载 #spring.devtools.restart.exclude=application.properties #通过触发器，去控制什么时候进行热加载部署新的文件 spring.devtools.restart.trigger-file=trigger.txt
然后在src\main\resources目录下，添加trigger.txt文件
version=1
这样你每次改好代码，不会每次保存就热部署，而是改好代码后，改version=2就会进行热部署。
注意点：生产环境不要开启这个功能，如果用java -jar启动，springBoot是不会进行热部署的
二、SpringBoot注解把配置文件自动映射到属性和实体类实战
方式一、Controller上面配置
简介：讲解使用@value注解配置文件自动映射到属性和实体类
1、配置文件加载
方式一
1、Controller上面配置
@PropertySource({"classpath:resource.properties"})
2、增加属性
@Value("${test.name}")
private String name;
举例
上篇的文件上传的地址我是写死的。
这样显然不科学，这里改成写在1.application.properties配置文件里。
#文件上传路径配置 web.file.path=C:/Users/chenww/Desktop/springbootstudy/springbootstudy/src/main/resources/static/images/
2在FileController 类中
@Controller
@PropertySource({"classpath:application.properties"})
public class FileController {
//文件放在项目的images下
// private String filePath = "C:\\Users\\chenww\\Desktop\\springbootstudy\\springbootstudy\\src\\main\\resources\\static\\images\\";
@Value("${web.file.path}")
private String filePath;
总结：
1：@PropertySource代表读取哪个文件
2：@Value通过key得到value值
方式二：实体类配置文件
步骤：
1、添加 @Component 注解；
2、使用 @PropertySource 注解指定配置文件位置；
3、使用 @ConfigurationProperties 注解，设置相关属性；
4、必须 通过注入IOC对象Resource 进来 ， 才能在类中使用获取的配置文件值。
@Autowired
private ServerSettings serverSettings;
案例：
1.在application.properties
#测试配置文件路径 test.domain=www.jincou.com test.name=springboot
2.创建ServerSettings实体
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
//服务器配置
@Component
@PropertySource({"classpath:application.properties"})
@ConfigurationProperties
public class ServerSettings {
//名称test.domain是key值
@Value("${test.domain}")
private String name;
//域名地址
@Value("${test.name}")
private String domain;
//提供set和get方法
}
三创建GetController
import com.jincou.model.ServerSettings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class GetController {
//需要注入
@Autowired
private ServerSettings serverSettings;
@GetMapping("/v1/test_properties")
public Object testPeroperties(){
return serverSettings;
}
}
页面效果
其实上面还可以做个优化：
创建ServerSettings实体
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
//服务器配置
@Component
@PropertySource({"classpath:application.properties"})
@ConfigurationProperties(prefix="test")
//这里加了个test前缀
public class ServerSettings {
//这是不需要写vlaue标签，只要text.name去掉前缀test后的name和这里name相同，就会自动赋值
private String name;
//域名地址
private String domain;
//提供set和get方法
}
单元测试，全局异常
一、单元测试
1.基础版
1、引入相关依赖
<!--springboot程序测试依赖，如果是自动创建项目默认添加--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency>
2：关键注解：@RunWith @SpringBootTest
import junit.framework.TestCase;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class) //底层用junit SpringJUnit4ClassRunner
@SpringBootTest(classes={SpringbootstudyApplication.class})//启动整个springboot工程
public class SpringBootTestDemo {
@Test
public void testOne(){
System.out.println("test hello 1");
TestCase.assertEquals(1, 1);
}
@Test
public void testTwo(){
System.out.println("test hello 2");
TestCase.assertEquals(1, 1);
}
@Before
public void testBefore(){
System.out.println("before");
}
@After
public void testAfter(){
System.out.println("after");
}
}
输出结果：
2.MockMvc
MockMvc类的使用和模拟Http请求实战
TestController
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class TestController {
@RequestMapping("/vq/test")
public String getTest(){
return"我是测试返回值";
}
}
MockMvcTestDemo
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.test.web.servlet.result.MockMvcResultMatchers;
/**
* 功能描述：测试mockmvc类
*
*/
@RunWith(SpringRunner.class) //底层用junit SpringJUnit4ClassRunner
@SpringBootTest(classes={SpringbootstudyApplication.class}) //启动整个springboot工程
@AutoConfigureMockMvc
public class MockMvcTestDemo {
@Autowired
private MockMvc mockMvc;
@Test
public void apiTest() throws Exception {
MvcResult mvcResult = mockMvc.perform( MockMvcRequestBuilders.get("/vq/test") ).
andExpect( MockMvcResultMatchers.status().isOk() ).andReturn();
int status = mvcResult.getResponse().getStatus();
System.out.println(status);
}
}
结果：返回200状态码
总结，关键注解：
@RunWith(SpringRunner.class) //底层用junit SpringJUnit4ClassRunner
@SpringBootTest(classes={SpringbootstudyApplication.class}) //启动整个springboot工程
@AutoConfigureMockMvc
二、配置全局异常
首先springboot自带异常是不友好的。
举例
@RequestMapping(value = "/api/v1/test_ext")
public Object index() {
int i= 1/0;
return new User(11, "sfsfds", "1000000", new Date());
}
页面
1、配置全局异常
import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;
//添加全局异常注解
@RestControllerAdvice
public class CustomExtHandler {
private static final Logger LOG = LoggerFactory.getLogger(CustomExtHandler.class);
//捕获全局异常,处理所有不可知的异常
@ExceptionHandler(value=Exception.class)
//@ResponseBody
Object handleException(Exception e,HttpServletRequest request){
LOG.error("url {}, msg {}",request.getRequestURL(), e.getMessage());
Map<String, Object> map = new HashMap<>();
map.put("code", 100);
map.put("msg", e.getMessage());
map.put("url", request.getRequestURL());
return map;
}
}
在看页面：
关键注解：
@RestControllerAdvice //全局注解
@ExceptionHandler(value=Exception.class) //捕获不同异常，这里捕获是Exception异常，你也可以指定其它异常
2.自定义异常
在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。
- 所有异常都必须是 Throwable 的子类。
- 如果希望写一个检查性异常类，则需要继承 Exception 类。
- 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。
1.自定义MyException异常
/**
* 功能描述：自定义异常类
*
*/
public class MyException extends RuntimeException {
private static final long serialVersionUID = 1L;
public MyException(String code, String msg) {
this.code = code;
this.msg = msg;
}
private String code;
private String msg;
public String getCode() {
return code;
}
public void setCode(String code) {
this.code = code;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}
controller类
/**
* 功能描述：模拟自定义异常
*/
@RequestMapping("/api/v1/myext")
public Object myexc(){
//直接抛出异常
throw new MyException("499", "my ext异常");
}
页面
过滤器，监听器，拦截器
一、理解它们
看里十几篇博客，总算有点小明白，总的来讲，两张图可以让我看明白点。
通过两幅图我们可以理解拦截器和过滤器的特点
1、过滤器
过滤器是在请求进入tomcat容器后，但请求进入servlet之前进行预处理的。请求结束返回也是，是在servlet处理完后，返回给前端之前。
理解上面这句话我们就可以知道，进入servlet之前，主要是两个参数：ServletRequest，ServletResponse 那我们得到这两个测试可以干哪些事呢？
我们可以通过ServletRequest得到HttpServletRequest,此时你就可以对请求或响应(Request、Response)那就可以对对web服务器管理的所有web资源：例如Jsp, Servlet, 静态图片文件或静态 html 文件等进行拦截，从而实现一些特殊的功能。例如实现URL级别的权限访问控制、过滤敏感词汇、压缩响应信息、字符集统一等一些高级功能。它主要用于对用户请求进行预处理，也可以对HttpServletResponse进行后处理。使用Filter的完整流程：Filter对用户请求进行预处理，接着将请求交给Servlet进行处理并生成响应，最后Filter再对服务器响应进行后处理。。它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关请求，只有当你的web应用停止或重新部署的时候才销毁。（每次热部署后，都会销毁）。
2、拦截器
从上图我们可以看出过滤器只在servlet前后起作用，所以它既不能捕获异常，获得bean对象等，这些是只能是进入servlet里面的拦截器能过做到。拦截器中用于在某个方法或字段被访问之前，进行拦截然后，在之前或之后加入某些操作。比如日志，安全等。一般拦截器方法都是通过动态代理的方式实现。可以通过它来进行权限验证，或者判断用户是否登陆，或者是像12306 判断当前时间是否是购票时间。
对比一下其实我们可以发现，过滤器能做的事拦截器都能做，二拦截器做的事过滤器不一定做的了。
3、监听器
listener是servlet规范中定义的一种特殊类。用于监听servletContext、HttpSession和servletRequest等域对象的创建和销毁事件。监听域对象的属性发生修改的事件。用于在事件发生前、发生后做一些必要的处理。其主要可用于以下方面：1、统计在线人数和在线用户2、系统启动时加载初始化信息3、统计网站访问量4、记录用户访问路径。
常用的监听器 servletContextListener、httpSessionListener、servletRequestListener)
二、如何创建他们
1、过滤器
自定义Filter 使用Servlet3.0的注解进行配置第三步的@WebFilter就是3.0的注解
1）启动类里面增加 @ServletComponentScan，进行扫描
2）新建一个Filter类，implements Filter，并实现对应的接口
3) @WebFilter 标记一个类为filter，被spring进行扫描
urlPatterns：拦截规则，支持正则
4）控制chain.doFilter的方法的调用，来实现是否通过放行不放行，web应用resp.sendRedirect("/index.html");场景：权限控制、用户登录(非前端后端分离场景)等
application类
@SpringBootApplication
@ServletComponentScan
public class SpringbootstudyApplication {
public static void main(String[] args) {
SpringApplication.run(SpringbootstudyApplication.class, args);
}
}
LoginFilter过滤器
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpServletResponseWrapper;
//过滤器拦截路径
@WebFilter(urlPatterns = "/api/*", filterName = "loginFilter")
public class LoginFilter 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 {
System.out.println("拦截中========拦截中========");
HttpServletRequest hrequest = (HttpServletRequest)servletRequest;
HttpServletResponseWrapper wrapper = new HttpServletResponseWrapper((HttpServletResponse) servletResponse);
if(hrequest.getRequestURI().indexOf("/index") != -1 ||
hrequest.getRequestURI().indexOf("/asd") != -1 ||
hrequest.getRequestURI().indexOf("/online") != -1 ||
hrequest.getRequestURI().indexOf("/login") != -1
) {
filterChain.doFilter(servletRequest, servletResponse);
}else {
wrapper.sendRedirect("/login");
}
}
/**
* 容器被销毁的时候被调用
*/
@Override
public void destroy() {
System.out.println("拦截器销毁========拦截器销毁========");
}
}
1、官网地址：https://docs.spring.io/spring-boot/docs/2.1.0.BUILD-SNAPSHOT/reference/htmlsingle/#boot-features-embedded-container-servlets-filters-listeners
二、监听器
import javax.servlet.ServletRequestEvent;
import javax.servlet.ServletRequestListener;
import javax.servlet.annotation.WebListener;
@WebListener
public class RequestListener implements ServletRequestListener {
@Override
public void requestDestroyed(ServletRequestEvent sre) {
// TODO Auto-generated method stub
System.out.println("======销毁监听器========");
}
@Override
public void requestInitialized(ServletRequestEvent sre) {
System.out.println("======进入监听器========");
}
三、拦截器
CustomWebMvcConfigurer主拦截器需要：
1：添加@Configuration注解
2：实现WebMvcConfigurer接口
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
//主拦截器，根据拦截不同路径跳转不同自定义拦截器 （实现WebMvcConfigurer方法）
@Configuration
public class CustomWebMvcConfigurer implements WebMvcConfigurer {
@Override
public void addInterceptors(InterceptorRegistry registry) {
registry.addInterceptor(new LoginIntercepter()).addPathPatterns("/api1/*/**");
registry.addInterceptor(new TwoIntercepter()).addPathPatterns("/api2/*/**");
//.excludePathPatterns("/api2/xxx/**"); //拦截全部 /*/*/**
WebMvcConfigurer.super.addInterceptors(registry);
}
}
LoginIntercepter子拦截器
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
public class LoginIntercepter implements HandlerInterceptor{
/**
* 进入controller方法之前
*/
@Override
public boolean preHandle(HttpServletRequest request,
HttpServletResponse response, Object handler) throws Exception {
System.out.println("LoginIntercepter------->preHandle");
// String token = request.getParameter("access_token");
//
// response.getWriter().print("fail");
return HandlerInterceptor.super.preHandle(request, response, handler);
}
/**
* 调用完controller之后，视图渲染之前
*/
@Override
public void postHandle(HttpServletRequest request,
HttpServletResponse response, Object handler,
ModelAndView modelAndView) throws Exception {
System.out.println("LoginIntercepter------->postHandle");
HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
}
/**
* 整个完成之后，通常用于资源清理
*/
@Override
public void afterCompletion(HttpServletRequest request,
HttpServletResponse response, Object handler, Exception ex)
throws Exception {
System.out.println("LoginIntercepter------->afterCompletion");
HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
}
}
TwoIntercepter同上
最后总解一下他们：
过滤器：用于属性甄别，对象收集（不可改变过滤对象的属性和行为）
监听器：用于对象监听，行为记录（不可改变监听对象的属性和行为）
拦截器：用于对象拦截，行为干预（可以改变拦截对象的属性和行为）
整合Mybaties增删改查
#数据驱动可配也可以不配，因为系统会自动识别 #spring.datasource.driver-class-name =com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/movie?useUnicode=true&characterEncoding=utf-8 spring.datasource.username =root spring.datasource.password =root #让控制台打印SQL语句，一般用于本地开发环境 mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl #springboot有自带数据源这个也可不配置 spring.datasource.type =com.alibaba.druid.pool.DruidDataSource
4.Springboot主类
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
//@MapperScan会自动扫描里面的包，而且应该是可以自动给每个类装配一个Bean对象
@SpringBootApplication
@MapperScan("com.jincou.mapper")
public class MainApplication {
public static void main(String[] args) {
SpringApplication.run(MainApplication.class, args);
}
}
5、UserMapper
import java.util.List;
import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Result;
import org.apache.ibatis.annotations.Results;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;
import com.jincou.model.User;
/**
* 功能描述：访问数据库的接口
*/
public interface UserMapper {
//推荐使用#{}取值，不要用${},因为存在注入的风险
@Insert("INSERT INTO user(name,phone,create_time,age) VALUES(#{name}, #{phone}, #{createTime},#{age})")
@Options(useGeneratedKeys=true, keyProperty="id", keyColumn="id") //keyProperty java对象的属性；keyColumn表示数据库的字段
int insert(User user);
//column指数据库中的列，property是指实体的属性名，如果一致就不需要写
@Select("SELECT * FROM user")
@Results({
@Result(column = "create_time",property = "createTime")
})
List<User> getAll();
@Select("SELECT * FROM user WHERE id = #{id}")
@Results({
@Result(column = "create_time",property = "createTime")
})
User findById(Long id);
@Update("UPDATE user SET name=#{name} WHERE id =#{id}")
void update(User user);
@Delete("DELETE FROM user WHERE id =#{userId}")
void delete(Long userId);
}
7、UserServiseImpl
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.jincou.mapper.UserMapper;
import com.jincou.model.User;
import com.jincou.service.UserService;
@Service
public class UserServiceImpl implements UserService{
//因为主类的@MapperScan方法，所以自动为UserMapper装配了一个userMapper对象
@Autowired
private UserMapper userMapper;
//这里你传过去的时候user的id为null,而insert之后传回回来的user会把数据库中的id值带回来，真强大
@Override
public int add(User user) {
userMapper.insert(user);
int id = user.getId();
return id;
}
}
8.Controller类
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.jincou.mapper.UserMapper;
import com.jincou.model.JsonData;
import com.jincou.model.User;
import com.jincou.service.UserService;
@RestController
@RequestMapping("/api/v1/user")
public class UserController {
//在UserServiceImpl定义了@Service实现类所以可以得到默认首字母小写的对象
@Autowired
private UserService userService;
@Autowired
private UserMapper userMapper;
/**
* 功能描述: user 保存接口
*/
@GetMapping("add")
public Object add(){
User user = new User();
user.setAge(11);
user.setCreateTime(new Date());
user.setName("张三");
user.setPhone("1880177");
int id = userService.add(user);
return id;
}
/**
* 功能描述：查找全部用户
* 这里和下面是直接调用跳过Servise层，直接到DAO层
*/
@GetMapping("findAll")
public Object findAll(){
return userMapper.getAll();
}
/**
* 查找单个用户
*/
@GetMapping("find_by_id")
public Object findById(long id){
return userMapper.findById(id);
}
/**
* 删除单个用户
*/
@GetMapping("del_by_id")
public Object delById(long id){
userMapper.delete(id);
return "";
}
/**
*更新用户
*/
@GetMapping("update")
public Object update(String name,int id){
User user = new User();
user.setName(name);
user.setId(id);
userMapper.update(user);
return "";
}
}
测试
1.准备好数据库数据：
#Sql脚本
CREATE TABLE `user` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(128) DEFAULT NULL COMMENT '名称',
`phone` varchar(16) DEFAULT NULL COMMENT '用户手机号',
`create_time` datetime DEFAULT NULL COMMENT '创建时间',
`age` int(4) DEFAULT NULL COMMENT '年龄',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;
2测试结果
插入用户，看后台的sql语句
Springboot整合redis
步骤讲解
1、第一步jar导入：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
如果你本地没有相应jar包，你可以在mevan存放jar包的库中，找到Setting文件，添加阿里云镜像，在跟新就可以下载相应jar包
<mirror>
<id>alimaven-central</id>
<mirrorOf>central</mirrorOf>
<name>aliyun maven</name>
<url>http://maven.aliyun.com/nexus/content/repositories/central/</url>
</mirror>
第二步：application.properties配置
配置
第三步创建实体
User类
User类JsonData工具类实体
/**
* 这是后端向前端响应的一个包装类
* 一般后端向前端传值会有三个属性
* 1：响应状态
* 2：如果响应成功，把数据放入
* 3: 描述，响应成功描述，或者失败的描述
*/
public class JsonData implements Serializable {
private static final long serialVersionUID = 1L;
private Integer code; // 状态码 0 表示成功，1表示处理中，-1表示失败
private Object data; // 数据
private String msg;// 描述
public JsonData() {
}
public JsonData(Integer code, Object data, String msg) {
this.code = code;
this.data = data;
this.msg = msg;
}
// 成功，只返回成功状态码
public static JsonData buildSuccess() {
return new JsonData(0, null, null);
}
// 成功，传入状态码和数据
public static JsonData buildSuccess(Object data) {
return new JsonData(0, data, null);
}
// 失败，传入描述信息
public static JsonData buildError(String msg) {
return new JsonData(-1, null, msg);
}
// 失败，传入描述信息,状态码
public static JsonData buildError(String msg, Integer code) {
return new JsonData(code, null, msg);
}
// 成功，传入数据,及描述信息
public static JsonData buildSuccess(Object data, String msg) {
return new JsonData(0, data, msg);
}
// 成功，传入数据,及状态码
public static JsonData buildSuccess(Object data, int code) {
return new JsonData(code, data, null);
}
//提供get和set方法，和toString方法
}
第四步创建工具类
1、字符串转对象，对象转字符串工具类
import java.io.IOException;
import org.springframework.util.StringUtils;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* 字符串转对象，对象转字符串的工具类
* 因为StringRedisTemplate的opsForValue()方法需要key,value都需要String类型，所以当value值存入对象的时候
* 先转成字符串后存入。
*/
public class JsonUtils {
private static ObjectMapper objectMapper = new ObjectMapper();
//对象转字符串
public static <T> String obj2String(T obj){
if (obj == null){
return null;
}
try {
return obj instanceof String ? (String) obj : objectMapper.writeValueAsString(obj);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
//字符串转对象
public static <T> T string2Obj(String str,Class<T> clazz){
if (StringUtils.isEmpty(str) || clazz == null){
return null;
}
try {
return clazz.equals(String.class)? (T) str :objectMapper.readValue(str,clazz);
} catch (IOException e) {
e.printStackTrace();
return null;
}
}
}
2、封装Redis类
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
/**
* 功能描述：redis工具类
* 对于redisTpl.opsForValue().set(key, value)进行了一次封装，不然每次都要这样保存值
* 而封装后只需：new RedisClient().set(key,value);
*/
@Component
public class RedisClient {
@Autowired
private StringRedisTemplate redisTpl; //jdbcTemplate
// 功能描述：设置key-value到redis中
public boolean set(String key ,String value){
try{
redisTpl.opsForValue().set(key, value);
return true;
}catch(Exception e){
e.printStackTrace();
return false;
}
}
// 功能描述：通过key获取缓存里面的值
public String get(String key){
return redisTpl.opsForValue().get(key);
}
}
第五步创建Controller类
RdisTestController
import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.jincou.model.JsonData;
import com.jincou.model.User;
import com.jincou.until.JsonUtils;
import com.jincou.until.RedisClient;
@RestController
@RequestMapping("/api/v1/redis")
public class RdisTestController {
//得到redis封装类
@Autowired
private RedisClient redis;
//添加字符串
@GetMapping(value="add")
public Object add(){
redis.set("username", "xddddddd");
return JsonData.buildSuccess();
}
//通过key值得到value字符串
@GetMapping(value="get")
public Object get(){
String value = redis.get("username");
return JsonData.buildSuccess(value);
}
//将对象通过工具类转成String类型，存入redis中
@GetMapping(value="save_user")
public Object saveUser(){
User user = new User(1, "abc", "11", new Date());
String userStr = JsonUtils.obj2String(user);
boolean flag = redis.set("base:user:11", userStr);
return JsonData.buildSuccess(flag);
}
//通过key值得到value值，让后将value转为对象
@GetMapping(value="find_user")
public Object findUser(){
String userStr = redis.get("base:user:11");
User user = JsonUtils.string2Obj(userStr, User.class);
return JsonData.buildSuccess(user);
}
}
测试效果
命名规范：如果我们key按"base:user:11"这来命名，那么那么会自动创建文件夹格式，方便查看。
