1 SpringBoot

1. 为什么要使用 Spring Boot
   因为Spring， SpringMVC 需要使用的大量的配置文件 （xml文件）
   还需要配置各种对象，把使用的对象放入到spring容器中才能使用对象
   需要了解其他框架配置规则。
2. SpringBoot 就相当于 不需要配置文件的Spring+SpringMVC。 常用的框架和第三方库都已经配置好了。
   拿来就可以使用了。
3. 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创建的三种方式

1. 使用地址： https://start.spring.io
   

2. 修改地址： https://start.springboot.io

3. 使用 maven 向导创建项目
   创建一个普通 maven 项目
   修改项目的目录
   
   添加 Spring Boot 依赖

   <dependencies>
   	<!--web起步依赖（SpringMVC功能）-->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>
   <build>
   	<plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
           </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 组成

1. @SpringBootConfiguration

   @Configuration
   public @interface SpringBootConfiguration {
       @AliasFor(
           annotation = Configuration.class
       )
       boolean proxyBeanMethods() default true;
   }
   
   说明：使用了@SpringBootConfiguration注解标注的类，可以作为配置文件使用的，
       可以使用@Bean声明对象，注入到容器
   

2. @EnableAutoConfiguration

   启用自动配置， 把java对象配置好，注入到spring容器中。例如可以把mybatis的对象创建好，放入到容器中

3. @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需要配置：

1. 加入一个处理jsp的依赖。 负责编译jsp文件

   <!--引入 Spring Boot 内嵌的 Tomcat 对 JSP 的解析包，不加解析不
   了 jsp 页面-->
   <!--如果只是使用 JSP 页面，可以只添加该依赖-->
   <dependency>
   	 <groupId>org.apache.tomcat.embed</groupId>
   	 <artifactId>tomcat-embed-jasper</artifactId>
   </dependency>
   

2. 如果需要使用servlet， jsp，jstl的功能

   <!--如果要使用 servlet 必须添加该以下两个依赖-->
   <!-- servlet 依赖的 jar 包-->
   <dependency>
   	 <groupId>javax.servlet</groupId>
   	 <artifactId>javax.servlet-api</artifactId>
   </dependency>
   <!-- jsp 依赖 jar 包-->
   <dependency>
   	 <groupId>javax.servlet.jsp</groupId>
   	 <artifactId>javax.servlet.jsp-api</artifactId>
   	 <version>2.3.1</version>
   </dependency>
   <!--如果使用 JSTL 必须添加该依赖-->
   <!--jstl 标签依赖的 jar 包 start-->
   <dependency>
   	 <groupId>javax.servlet</groupId>
   	 <artifactId>jstl</artifactId>
   </dependency>
   

3. 在main目录下创建一个存放jsp的目录，一般叫做webapp
   ​ index.jsp

4. 需要在pom.xml指定jsp文件编译后的存放目录。
   META-INF/resources

   <resources>
   	<resource>
   		<!--源文件位置-->
   		<directory>src/main/webapp</directory>
   		<!--指定编译到META-INF/resource，该目录不能随便写-->
   		<targetPath>META-INF/resources</targetPath>
   		<!--指定要把哪些文件编译进去，**表示 webapp 目录及子目录，*.*表示所有文件-->
   		<includes>
   			<include>**/*.*</include>
   		</includes>
   	</resource>
   </resources>
   

5. 在application.propertis文件中配置视图解析器

   #配置 SpringMVC 的视图解析器
   #其中：/相当于 src/main/webapp 目录
   spring.mvc.view.prefix=/
   spring.mvc.view.suffix=.jsp
   

6. 创建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中实现自定义拦截器：

1. 创建类实现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 {
    }
   }
   

2. 需在SpringMVC的配置文件中，声明拦截器

   <mvc:interceptors>
   	<mvc:interceptor>
       	<mvc:path="url" />
           <bean class="拦截器类全限定名称"/>
       </mvc:interceptor>
   </mvc:interceptors>
   

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对象。

使用步骤：

1. 创建Servlet类。 创建类继承HttpServlet
2. 注册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"); // <url-pattern>

        return bean;
    }
}

2.3 过滤器Filter

Filter是Servlet规范中的过滤器，可以处理请求， 对请求的参数， 属性进行调整。 常常在过滤器中处理字符编码

在框架中使用过滤器：

1. 创建自定义过滤器类
2. 注册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 注册过滤器。 配置他的属性。

第一种方式：
使用步骤：

1. 配置字符集过滤器

   @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;
       }
   }
   

2. 修改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

使用步骤：

1. mybatis起步依赖 ： 完成mybatis对象自动配置， 对象放在容器中

   <dependencies>
       <!--web的起步依赖-->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-web</artifactId>
       </dependency>
       <!--mybatis的起步依赖-->
       <dependency>
           <groupId>org.mybatis.spring.boot</groupId>
           <artifactId>mybatis-spring-boot-starter</artifactId>
           <version>2.3.0</version>
       </dependency>
       <!--mysql驱动-->
       <dependency>
           <groupId>com.mysql</groupId>
           <artifactId>mysql-connector-j</artifactId>
           <scope>runtime</scope>
       </dependency>
       <!--测试-->
       <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-test</artifactId>
           <scope>test</scope>
       </dependency>
   </dependencies>
   

2. pom.xml 指定把src/main/java目录中的xml文件包含到classpath中

   <!--resources插件-->
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.xml</include>
           </includes>
       </resource>
   </resources>
   

3. 创建实体类Student

   package com.yrgdcx.model;
   
   public class Student {
       private Integer id;
       private String name;
       private Integer age;
       // get、set、toString方法
   

4. 创建Mapper接口 StudentMapper , 创建一个查询学生的方法

   package com.yrgdcx.mapper;
   
   @Mapper
   public interface StudentMapper {
       Student selectById(@Param("stuId") Integer id);
   }
   

5. 创建Mapper接口对应的Mapper文件， xml文件， 写sql语句

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   
   <mapper namespace="com.yrgdcx.mapper.StudentMapper">
       <!--定义sql语句-->
       <select id="selectById" resultType="com.yrgdcx.model.Student">
           select id,name,age from student where id = #{stuId}
       </select>
   </mapper>
   

6. 创建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;
       }
   }
   

7. 创建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();
       }
   }
   

8. 写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目录下

1. 在resources目录中创建子目录 （自定义的） ， 例如mapper

2. 把mapper文件放到 mapper目录中

3. 在application.properties文件中，指定mapper文件的目录

   #指定mapper文件的位置
   mybatis.mapper-locations=classpath:mapper/*.xml
   

4. 在pom.xml中指定 把resources目录中的文件 ， 编译到目标目录中

   <!--resources插件-->
   <resources>
      <resource>
         <directory>src/main/resources</directory>
         <includes>
            <include>**/*.*</include>
         </includes>
      </resource>
   </resources>
   

事务

Spring框架中的事务：

1. 管理事务的对象： 事务管理器（接口， 接口有很多的实现类）

​ 例如：使用Jdbc或mybatis访问数据库，使用的事务管理器：DataSourceTransactionManager

2. 声明式事务： 在xml配置文件或者使用注解说明事务控制的内容

​ 控制事务： 隔离级别，传播行为， 超时时间

3. 事务处理方式：

   1. Spring框架中的@Transactional

   2. aspectj框架可以在xml配置文件中，声明事务控制的内容

SpringBoot中使用事务： 上面的两种方式都可以。

1）在业务方法的上面加入@Transactional , 加入注解后，方法有事务功能了。

2）在主启动类的上面 ，加入@EnableTransactionManager