SpringBoot学习笔记上
文章目录
- 1 SpringBoot
-
- 1.1 SpringBoot介绍
- 1.2 SpringBoot创建的三种方式
- 1.3@SpringBootApplication注解
- 1.4 SpringBoot的配置文件
- 1.5多环境配置
- 1.6 使用jsp
- 1.7 ComnandLineRunner 接口 ， ApplcationRunner接口
- 2 Web组件
-
- 2.1 拦截器
- 2.2 Servlet
- 2.3 过滤器Filter
- 2.4 字符集过滤器
- 3 ORM 操作 MySQL
-
-
- 第一种方式 ： @Mapper
- 第二种方式 @MapperScan
- 第三种方式： Mapper文件和Mapper接口分开管理
- 事务
-
1 SpringBoot
- 为什么要使用 Spring Boot
因为Spring， SpringMVC 需要使用的大量的配置文件 （xml文件）
还需要配置各种对象，把使用的对象放入到spring容器中才能使用对象
需要了解其他框架配置规则。 - SpringBoot 就相当于 不需要配置文件的Spring+SpringMVC。 常用的框架和第三方库都已经配置好了。
拿来就可以使用了。 - SpringBoot开发效率高，使用方便多了
1.1 SpringBoot介绍
SpringBoot是Spring中的一个成员， 可以简化Spring，SpringMVC的使用。 他的核心还是IOC容器。
特点：
-
Create stand-alone Spring applications
创建spring应用 -
Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files)
内嵌的tomcat， jetty ， Undertow -
Provide opinionated ‘starter’ dependencies to simplify your build configuration
提供了starter起步依赖，简化应用的配置。
比如使用MyBatis框架 ， 需要在Spring项目中，配置MyBatis的对象 SqlSessionFactory ， Dao的代理对象
在SpringBoot项目中，在pom.xml里面, 加入一个 mybatis-spring-boot-starter依赖 -
Automatically configure Spring and 3rd party libraries whenever possible
尽可能去配置spring和第三方库。叫做自动配置（就是把spring中的，第三方库中的对象都创建好，放到容器中， 开发人员可以直接使用）
-
Provide production-ready features such as metrics, health checks, and externalized configuration
提供了健康检查， 统计，外部化配置
-
Absolutely no code generation and no requirement for XML configuration
不用生成代码， 不用使用xml，做配置
1.2 SpringBoot创建的三种方式
-
使用地址： https://start.spring.io
-
修改地址： https://start.springboot.io
-
使用 maven 向导创建项目
创建一个普通 maven 项目
修改项目的目录
添加 Spring Boot 依赖<dependencies> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-webartifactId> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-testartifactId> <scope>testscope> dependency> dependencies> <build> <plugins> <plugin> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-maven-pluginartifactId> plugin> plugins> build>创建启动类：加入@SpringBootApplication 注解
package com.yrgx; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }
1.3@SpringBootApplication注解
@SpringBootApplication
复合注解：由
@SpringBootConfiguration
@EnableAutoConfiguration
@ComponentScan 组成
-
@SpringBootConfiguration
@Configuration public @interface SpringBootConfiguration { @AliasFor( annotation = Configuration.class ) boolean proxyBeanMethods() default true; } 说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用的， 可以使用@Bean声明对象，注入到容器 -
@EnableAutoConfiguration
启用自动配置， 把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中
-
@ComponentScan
@ComponentScan 组件扫描器，扫描注解，根据注解的功能创建对象，给属性赋值等等。 默认扫描的包： @ComponentScan所在的类所在的包和子包。
1.4 SpringBoot的配置文件
配置文件名称： application
扩展名有： properties( k=v) ; yml ( k: v)
使用application.properties, application.yml
例1：application.properties设置 端口和上下文
#设置端口号
server.port=8082
#设置访问应用上下文路径， contextpath
server.servlet.context-path=/myboot
例2： application.yml
server:
port: 8083
servlet:
context-path: /myboot2
1.5多环境配置
有开发环境， 测试环境， 上线的环境。
每个环境有不同的配置信息， 例如端口， 上下文件， 数据库url，用户名，密码等等
使用多环境配置文件，可以方便的切换不同的配置。
使用方式： 创建多个配置文件， 名称规则： application-环境名称.properties(yml)
创建开发环境的配置文件： application-dev.properties
# 开发使用的配置文件
server.port=8081
server.servlet.context-path=/mydev
创建测试者使用的配置： application-test.properties
# 测试使用的配置文件
server.port=9001
server.servlet.context-path=/mytest
application.properties
# 激活使用开发的测试环境
spring.profiles.active=dev
1.6 使用jsp
SpringBoot不推荐使用jsp ，而是使用模板技术代替jsp
使用jsp需要配置：
-
加入一个处理jsp的依赖。 负责编译jsp文件
<dependency> <groupId>org.apache.tomcat.embedgroupId> <artifactId>tomcat-embed-jasperartifactId> dependency> -
如果需要使用servlet， jsp，jstl的功能
<dependency> <groupId>javax.servletgroupId> <artifactId>javax.servlet-apiartifactId> dependency> <dependency> <groupId>javax.servlet.jspgroupId> <artifactId>javax.servlet.jsp-apiartifactId> <version>2.3.1version> dependency> <dependency> <groupId>javax.servletgroupId> <artifactId>jstlartifactId> dependency> -
在main目录下创建一个存放jsp的目录，一般叫做webapp
index.jsp -
需要在pom.xml指定jsp文件编译后的存放目录。
META-INF/resources<resources> <resource> <directory>src/main/webappdirectory> <targetPath>META-INF/resourcestargetPath> <includes> <include>**/*.*include> includes> resource> resources> -
在application.propertis文件中配置视图解析器
#配置 SpringMVC 的视图解析器 #其中：/相当于 src/main/webapp 目录 spring.mvc.view.prefix=/ spring.mvc.view.suffix=.jsp -
创建Controller， 访问jsp
1.7 ComnandLineRunner 接口 ， ApplcationRunner接口
这两个接口都 有一个run方法。 执行时间在容器对象创建好后， 自动执行run（）方法。
可以完成自定义的在容器对象创建好的一些操作
@FunctionalInterface
public interface CommandLineRunner {
void run(String... args) throws Exception;
}
@FunctionalInterface
public interface ApplicationRunner {
void run(ApplicationArguments args) throws Exception;
}
2 Web组件
2.1 拦截器
拦截器是SpringMVC中一种对象，能拦截器对Controller的请求。
拦截器框架中有系统的拦截器， 还可以自定义拦截器。 实现对请求预先处理。
在SpringMVC中实现自定义拦截器：
- 创建类实现SpringMVC框架的HandlerInterceptor接口
public interface HandlerInterceptor { default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception { return true; } default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception { } default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception { } } - 需在SpringMVC的配置文件中，声明拦截器
<mvc:interceptors> <mvc:interceptor>
SpringBoot中注册拦截器：
public class LoginInterceptor implements HandlerInterceptor {
/**
* @param handler 被拦截器的控制器对象
* @return boolean
* true:请求能被Controller处理
* false:请求被截断
*/
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println("执行了LoginInterceptor的preHandle方法");
return true;
}
}
@Configuration
public class MyAppConfig implements WebMvcConfigurer {
//添加拦截器对象， 注入到容器中
@Override
public void addInterceptors(InterceptorRegistry registry) {
//创建拦截器对象
HandlerInterceptor interceptor = new LoginInterceptor();
//指定拦截的请求uri地址
String path []= {"/user/**"};
//指定不拦截的地址
String excludePath [] = {"/user/login"};
registry.addInterceptor(interceptor)
.addPathPatterns(path)
.excludePathPatterns(excludePath);
}
}
2.2 Servlet
在SpringBoot框架中使用Servlet对象。
使用步骤：
- 创建Servlet类。 创建类继承HttpServlet
- 注册Servlet ，让框架能找到Servlet
a. 创建自定义Servlet
//创建Servlet类
public class MyServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doPost(req,resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//使用HttpServletResponse输出数据，应答结果
resp.setContentType("text/html;charset=utf-8");
PrintWriter out = resp.getWriter();
out.println("===执行的是Servlet==");
out.flush();
out.close();
}
}
b. 注册Servlet
@Configuration
public class WebApplictionConfig {
//定义方法， 注册Servlet对象
@Bean
public ServletRegistrationBean servletRegistrationBean(){
//public ServletRegistrationBean(T servlet, String... urlMappings)
//第一个参数是 Servlet对象， 第二个是url地址
//ServletRegistrationBean bean = new ServletRegistrationBean( new MyServlet(),"/myservlet");
ServletRegistrationBean bean = new ServletRegistrationBean();
bean.setServlet( new MyServlet());
bean.addUrlMappings("/login","/test"); // 2.3 过滤器Filter
Filter是Servlet规范中的过滤器，可以处理请求， 对请求的参数， 属性进行调整。 常常在过滤器中处理字符编码
在框架中使用过滤器：
- 创建自定义过滤器类
- 注册Filter过滤器对象
自定义过滤器
public class MyFilter implements Filter {
@Override
public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
System.out.println("执行了MyFilter，doFilter ");
filterChain.doFilter(servletRequest,servletResponse);
}
}
注册Filter
@Configuration
public class WebApplicationConfig {
@Bean
public FilterRegistrationBean filterRegistrationBean(){
FilterRegistrationBean bean = new FilterRegistrationBean();
bean.setFilter( new MyFilter());
bean.addUrlPatterns("/user/*");
return bean;
}
}
2.4 字符集过滤器
CharacterEncodingFilter : 解决post请求中乱码的问题
在SpringMVC框架， 在web.xml 注册过滤器。 配置他的属性。
第一种方式：
使用步骤：
-
配置字符集过滤器
@Configuration public class WebSystemConfig { //注册Filter @Bean public FilterRegistrationBean filterRegistrationBean(){ FilterRegistrationBean reg = new FilterRegistrationBean(); //使用框架中的过滤器类 CharacterEncodingFilter filter = new CharacterEncodingFilter(); //指定使用的编码方式 filter.setEncoding("utf-8"); //指定request ， response都使用encoding的值 filter.setForceEncoding(true); reg.setFilter(filter); //指定 过滤的url地址 reg.addUrlPatterns("/*"); return reg; } } -
修改application.properties文件， 让自定义的过滤器起作用
#SpringBoot中默认已经配置了CharacterEncodingFilter。 编码默认ISO-8859-1 #设置enabled=false 作用是关闭系统中配置好的过滤器， 使用自定义的CharacterEncodingFilter server.servlet.encoding.enabled=false
第二种方式
修改application.properties文件
#让系统的CharacterEncdoingFilter生效
server.servlet.encoding.enabled=true
#指定使用的编码方式
server.servlet.encoding.charset=utf-8
#强制request，response都使用charset属性的值
server.servlet.encoding.force=true
3 ORM 操作 MySQL
使用MyBatis框架操作数据， 在SpringBoot框架集成MyBatis
使用步骤：
-
mybatis起步依赖 ： 完成mybatis对象自动配置， 对象放在容器中
<dependencies> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-webartifactId> dependency> <dependency> <groupId>org.mybatis.spring.bootgroupId> <artifactId>mybatis-spring-boot-starterartifactId> <version>2.3.0version> dependency> <dependency> <groupId>com.mysqlgroupId> <artifactId>mysql-connector-jartifactId> <scope>runtimescope> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-testartifactId> <scope>testscope> dependency> dependencies> -
pom.xml 指定把src/main/java目录中的xml文件包含到classpath中
<resources> <resource> <directory>src/main/javadirectory> <includes> <include>**/*.xmlinclude> includes> resource> resources> -
创建实体类Student
package com.yrgdcx.model; public class Student { private Integer id; private String name; private Integer age; // get、set、toString方法 -
创建Mapper接口 StudentMapper , 创建一个查询学生的方法
package com.yrgdcx.mapper; @Mapper public interface StudentMapper { Student selectById(@Param("stuId") Integer id); } -
创建Mapper接口对应的Mapper文件， xml文件， 写sql语句
DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.yrgdcx.mapper.StudentMapper"> <select id="selectById" resultType="com.yrgdcx.model.Student"> select id,name,age from student where id = #{stuId} select> mapper> -
创建Service层对象， 创建StudentService接口和他的实现类。 去调用Mapper对象的方法。完成数据库的操作
package com.yrgdcx.service; public interface StudentService { Student queryStudent(Integer id); }package com.yrgdcx.service.impl; @Service public class StudentServiceImpl implements StudentService { @Resource private StudentMapper studentMapper; @Override public Student queryStudent(Integer id) { Student student = studentMapper.selectById(id); return student; } } -
创建Controller对象，访问Service。
package com.yrgdcx.controller; @Controller public class StudentController { @Resource private StudentService studentService; @RequestMapping("/student/query") @ResponseBody public String queryStudent(Integer id){ Student student = studentService.queryStudent(id); return student.toString(); } } -
写application.properties文件，配置数据库的连接信息。
server.port=8081 server.servlet.context-path=/orm # 连接数据库 spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/springbootdb?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8 spring.datasource.username=root spring.datasource.password=root
第一种方式 ： @Mapper
@Mapper：放在Mapper接口的上面， 每个接口都需要使用这个注解。
/**
* @Mapper：告诉MyBatis这是Mapper接口，创建此接口的代理对象。
* 位置：在类的上面
*/
@Mapper
public interface StudentMapper {
Student selectById(@Param("stuId") Integer id);
}
第二种方式 @MapperScan
/**
* @MapperScan: 找到Mapper接口和Mapper文件
* basePackages：Mapper接口所在的包名
*/
@SpringBootApplication
@MapperScan(basePackages = {"com.yrgdcx.mapper"})
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
第三种方式： Mapper文件和Mapper接口分开管理
把Mapper文件放在resources目录下
-
在resources目录中创建子目录 （自定义的） ， 例如mapper
-
把mapper文件放到 mapper目录中
-
在application.properties文件中，指定mapper文件的目录
#指定mapper文件的位置 mybatis.mapper-locations=classpath:mapper/*.xml -
在pom.xml中指定 把resources目录中的文件 ， 编译到目标目录中
<resources> <resource> <directory>src/main/resourcesdirectory> <includes> <include>**/*.*include> includes> resource> resources>
事务
Spring框架中的事务：
- 管理事务的对象： 事务管理器（接口， 接口有很多的实现类）
例如：使用Jdbc或mybatis访问数据库，使用的事务管理器：DataSourceTransactionManager
- 声明式事务： 在xml配置文件或者使用注解说明事务控制的内容
控制事务： 隔离级别，传播行为， 超时时间
-
事务处理方式：
-
Spring框架中的@Transactional
-
aspectj框架可以在xml配置文件中，声明事务控制的内容
-
SpringBoot中使用事务： 上面的两种方式都可以。
1）在业务方法的上面加入@Transactional , 加入注解后，方法有事务功能了。
2）在主启动类的上面 ，加入@EnableTransactionManager