三、SpringBootApplication注解解析

一、 SpringBoot简介

Pivotal团队提供的全新框架简化Spring应用的初始搭建以及开发过程特定的方式来进行配置

springboot(微框架) = springmvc(控制器) + spring(项目管理)

1、什么是SpringBoot?

Spring是全新框架

2、作用

**简化Spring应用的初始化搭建 以及开发过程** 

简化初始搭建：通过特定的配置方式简化**替代** 这些配置`Spring.xml Springmvc.xml web.xml`（取消）

3、本质

SpringBoot本质就是基于Spring和SpringMVC的再封装

springboot(微框架) = springmvc(控制器框架) + spring(项目管理)

微框架（少量配置 简化开发）是微服务（SpringCloud）的所依赖的框架

4、SpringBoot的好处

创建独立的Spring应用程序应用中嵌入的Tomcat服务器，无需部署WAR文件，无需通过外部服务器部署简化Maven配置自动配置Spring，自动使用spring和springmvc所有机制和功能没有XML配置

5、搭建环境

（1）全局入口类

项目名+Application.javapublic static void main(String[] args){})

maven项目：

src/main/java
        cccom.tjcu.entity
                   .dao
                   .service
                   .......
                   XxxApplication.java

src/main/resources
         application.yml
src/test/java
src/test/resources

（2)SpringBoot的配置文件

1、位置：根下 maven项目 必须放在src/main/resources
2、名字：名字必须叫application.xxx
后缀：.yml |.yaml .properties
yml文件 简介 高效 语法要求严格
.properties key=value 会冗余，可读性强，映射关系明显

二、第一个SpringBoot应用程序搭建

0、环境版本要求

SpringBoot 2.2.5

Spring 5.x

Maven3.3以上（当前使用版本3.5.3）

JDK1.8+

Tomcat8.0+ 内置9.x的版本号

1、搭建开发环境（引入相关依赖）

基础2 parent web

<!--继承springboot的父项目 ,放在dependencies平级下-->
<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.2.5.RELEASE</version>
</parent>

<!--设置JDK版本为8-->
<properties>
    <maven.compiler.source>8</maven.compiler.source>
    <maven.compiler.target>8</maven.compiler.target>
</properties>

<dependencies>
    <!--springboot依赖-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

2、引入SpringBoot相关的配置文件

名字：application.yml

位置：根下 src/main/resource下

3、引入全局入口类

位置：和所有子包平级

名字：xxxApplication.java|Application.java

内容：必须存在一个主函数

com.tjcu
     @SpringBootApplication
     public class Application{
        public static void main(String[] args){
             /**
         * 自动Springboot应用
         * 参数1：入口类的类对象
         * 参数2：主函数的形参
         */
        SpringApplication.run(Application.class,args);

        }
     }

@SpringBootApplication

• spring版本号：2.2.5

• 启动SpringBoot后

• SpringBoot项目访问界面

4、开发一个控制器（书写一个Controller)

/**
 * @author 王恒杰
 * @date 2021/11/24 15:00
 * @Description:
 */
@Controller
@RequestMapping("test")
public class TestController {
    
  
    @RequestMapping("test1")
      @ResponseBody//响应Json的形式
    public String test1(){
        System.out.println("--------springboot----------");
        //跳转 Springboot默认不支持jsp
        return  "first SpringBoot application";
    }
}

• 注意事项：

1、SpringBoot应用内嵌服务器默认端口8080

2、SpringBoot应用访问时默认没有项目名

3、http://localhost:8080/test/test1

Application.yml

server:    #端口号修改设置
  port: 8989
  servlet:
    context-path: /Springboot  #设置当前的应用名

5、返回页面

三、SpringBootApplication注解解析

@SpringBootApplication

@Target({ElementType.TYPE})：``这个注解写在类上``
@Retention(RetentionPolicy.RUNTIME) ``会在运行时生效``
@Documented ``会生成注释文档``
@Inherited ``注解可以被继承

1、@SpringBootConfiguration ：（Spring.xml.Springmvc.xml）

2、@EnableAutoConfiguration：


3、@ComponentScan

/**
 * @author 王恒杰
 * @date 2021/11/24 14:45
 * @Description:
 * 入口类
 *
 */
//@SpringBootApplication //注解 标识SpringBoot入口
@SpringBootConfiguration //配置Spring+Springmvc的初始化配置
@EnableAutoConfiguration  //将配置Spring+Springmvc初始化配置实例化
@ComponentScan(value ="com.tjcu")//扫描当前包及其子包结构下的注解
public class Application {
    public static void main(String[] args) {
        /**
         * 自动Springboot应用
         * 参数1：入口类的类对象
         * 参数2：主函数的形参
         */
        SpringApplication.run(Application.class,args);

    }
}

四、SpringBoot配置文件的拆分

1、为什么要拆分配置文件

在实际开发过程中生产环境和测试环境有可能是不一样的，因此将生产中的配置和测试中的配置拆分开,是非常必要的，在springboot中也提供了配置文件拆分的方式

2、以生产中项目名称不一致为例:

（1)Application.yml 主配置

#主配置文件:
      application.yml  #用来书写相同的的配置
        server:
          port: 8080 #生产和测试为同一个端口

（2）开发中小配置文件application-.yml

  #生产配置文件:
        application-pord.yml
          server:
            context-path: /whj

（3）测试中小配置文件application-xxx.yml

 #测试配置文件:
        application-dev.yml
          server:
            context-path: /springboot

（4）上线中小配置文件application-xxx.yml

 #上线配置文件:
        application-dev.yml
          server:
            context-path: /tjcu

3、开发后小配置文件后我们需要在主配置文件中进行引用当前所需要的小配置文件

profiles[ˈproʊfaɪlz：轮廓

server:    #端口号设置
  port: 8989
spring:
  profiles:
    active: test   #设置集合的小配置文件application-test.yml 设置当前的应用名

4、作用

避免反复修改配置 ，方便后期的维护

五、SpringBoot对象的创建方式

1、Spring创建对象？

（1）简单对象和复杂对象区别

• 简单对象：可以直接通过new关键字直接创建对象

• 复杂对象：不能直接new的对象，就是复制对象（抽象类，接口，Connection）

• 管理方式：FactoryBean 接口

class xxxFactoryBean implement FactoryBean<Connnlection>{
   Connection.getObject();
   Class.forName("driver");
   return DriverManager.getConnecction("url","username","password")
}
Class getObjectType(){
return Connection.class;
}
boolen isSingleton(){
return false;
}

交给Spring管理

<bean class="xx.ConnectionFactoryBean" id="conn">

2、SpringBoot如何创建对象？

核心：使用注解

（1）简单对象

简单组件

# 1.使用 @Repository [rɪˈpɑːzətɔːri]   @Service @Controller 以及@Component管理不同简单对象

• 比如要通过工厂创建自定义User对象:

//负责创建简单对象
@Component("User")

//Sscope负责单例：Singleton 多例:prototype
@Scope("prototype")
public class User {
    private Integer id;
    private String username;
    private String password;

• 通过工厂创建之后可以在使用处任意注入该对象

如:在控制器中使用自定义简单对象创建

@Controller
@Scope("prototype")
@RequestMapping("test")
public class TestController {
    /**
     * 在控制方法中注入User
     */
    @Autowired
    private User user;
    @Autowired
    private User user1;

    @RequestMapping("test1")
    /**
     * json形式返回页面
     */
    @ResponseBody
    public String test1(){
        System.out.println("--------test1-------");
        System.out.println(user);
        System.out.println(user1);
        return "test1 method";
    }

会出现多例，创建了两个不同的对象

（2）管理多个对象

@Configuration+@Bean

@Configuration

@Bean

简单对象管理：

@Configuration
public class ObjectConfig {
    /**
     * 返回值返回的是要创建的类型 方法名随意
     * @return
     */
    @Bean("User")
    @Scope("prototype")
    public User getUser(){
    // 书写对象的创建过程
        return  new User();
    }
}

复杂对象管理：

六、SpringBoot集成JSP页面展示

1、当前控制器中不能直接返回jsp逻辑名（页面的名字） 出现404

SpringBoot框架默认集成Thymeleaf

2、集成jsp页面

（1）引入jsp的集成jar包

<dependency>
    <groupId>jstl</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

<!--2.2.5 之后最新版本中无须引入-->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-tomcat</artifactId>
</dependency>

<dependency>
    <groupId>org.apache.tomcat.embed</groupId>
    <artifactId>tomcat-embed-jasper</artifactId>
</dependency>

（2）在应用中配置页面路径的前后缀

• 在application.properties

#配置jsp页面的前后缀
spring.mvc.view.prefix=/
spring.mvc.view.suffix=.jsp

（3)访问页面路径正常 但是展示404

      在项目中添加SpringBoot相关插件，引入jsp运行插件

  <build>
  <!--当前项目部署到服务器之后的名字-->
      <finalName>SpringBoot2</finalName>
      <!--引入jsp运行插件-->
      <plugins>
        <plugin>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-maven-plugin</artifactId>
          <configuration>
            <jvmArguments>-Dfile.encoding=UTF-8</jvmArguments>
          </configuration>
        </plugin>
      </plugins>
  </build>

通过插件启动SpringBoot项目

效果:

@Controller
@Scope("prototype")
@RequestMapping("test")
public class TestController {
    @RequestMapping("test2")
    public String test2(){
        System.out.println("---test2----");
        return  "index";
    }

• 解决思路二：在IDEA中配置工作资源的路径

Edit Configurations

启动访问jsp页面

http://localhost:8989/test/test2

七、SpringBoot整合Mybatis

1、Spring+Mybatis整合思路

Spring myabtis mybatis-spring mysql druid

2、SpringBoot整合Mybatis

（1）引入依赖

<!--整合mybatis，由myabtis官方提供，需要版本号-->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.2</version>
</dependency>

<!--引入springboot的web支持-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.16</version>
    </dependency>

  <!--数据源连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.12</version>
    </dependency>

（2）编程步骤

@Service+@Transactional+@Autowired(Dao)DriverClassName url username password

(3)数据源相关的配置

#数据源相关配置 driverClassName url username password
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/db1?useSSL=false&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=root

（3）告知mapper文件所在路径 别名

#设置mybatis的mapper文件所在路径 别名
mybatis.mapper-locations=classpath:com/mapper/xxxMapper.xml
mybatis.type-aliases-package=com.tjcu.entity

（4)告知Dao接口所在包

不在配置文件进行配置，在入口类上完成包的扫描

@MapperScan("dao接口所在的包")

@SpringBootApplication
@MapperScan("com.tjcu.dao")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class,args);
    }
}

八、SpringBoot测试

1、引入相关依赖,内部包含原有的测试依赖

<!--引入springboot的test支持-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
    </dependency>

2、测试类和方法书写 考虑：测试时要启动SpringBoot的应用

(1)写一个父测试类，将SpringBoot中测试所需要的注解写在父测试类上

/*在测试类实例化的同时去启动springboot应用  
等价于 new ClassPathXMlApplicationContext();
*/
@RunWith(SpringRunner.class)
//指定测试类启动时入口类的位置  //等价于指定工厂的位置
@SpringBootTest(classes = EmsApplication.class)
public class ParentTest {
}

（2）不同实体类相关的测试就可以继承父测试类直接写测试了

• Admin的测试类

public class AdminTest extends  ParentTest{
    @Autowired
    private AdminService adminService;

    @Test
    public void select(){
        Admin admin = new Admin();
        admin.setName("王恒杰");
        admin.setPassword("123456");
        Admin admin1 = adminService.login(admin);
        System.out.println(admin);
    }
}

• 可以再写一个emp测试类继承父测试类

public class EmpTest extends ParentTest {

}

• 好处：就是可以少写点代码

九、SpringBoot中开启jsp的热部署

1、热部署

在不启动应用的前提下，让jsp页面修改生效

2、在配置文件中进行配置就可以了

• application.proprestis版本

#开启jsp页面的热部署
server.servlet.jsp.init-parameters.development=true

• application.yml

 jsp-servlet:
    init-parameters:
      development: true  #开启jsp页面的调试模式

十、SpringBoot切面编程

springboot是对原有项目中spring框架和springmvc的进一步封装,因此在springboot中同样支持spring框架中AOP切面编程,不过在springboot中为了快速开发仅仅提供了注解方式的切面编程.

1、切面编程Aop面向切面编程 切面=通知+切入点

2、Spring怎么样完成AOP编程

a、开发通知 额外通知

前置通知 MethodBeforeAdvice

环绕通知 MethodInterceptor

后置通知 MethodRunterningAdvice

异常通知 ThrowsAdvice

1、写类 Implements通知接口

2、在Spring中进行配置

<bean id="myadvice" class="">

b、aop相关设置aop:config

1、配置切入点

2、组装切面

<aop:config>
<aop:pointcut id="pc" expression="execution(* com.tjcu.service.*(..))"
</aop:config>

3、SpringBoot怎么完成Aop编程 核心：注解

(1)引入相关依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

（2）通知相关的注解：方法上

@Before 前置通知 方法参数joinPonit
@After 后置通知   方法参数 joinpoint
@Around 环绕通知

@Before(value="切入点表达式")
public void mytest1(){
System.out.println("xxxxxx");
}

切面相关注解：@Aspect 书写类上 标识当前类是一个切面配置类

4、SpringBoot中前置通知和后置通知

//创建对象
@Component
//标识当前类式切面配置类
@Aspect
public class AspectConfig{

    //前置通知   value属性 书写切入点表达式
    @Before("execution(* com.baizhi.service.*ServiceImpl.*(..))")
    public void myBefore(JoinPoint joinPoint) {
        System.out.println("-------------进入前置通知-----------");
        System.out.println("方法名：" + joinPoint.getSignature());
        System.out.println("参数：" + joinPoint.getArgs());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("-------------退出前置通知-----------");
    }

    //后置通知  value属性 书写切入点表达式
    @After("within(com.baizhi.service.*ServiceImpl)")
    public void myAfter(JoinPoint joinPoint) {
        System.out.println("-------------进入后置通知-----------");
        System.out.println("方法名：" + joinPoint.getSignature());
        System.out.println("参数：" + joinPoint.getArgs());
        System.out.println("目标对象：" + joinPoint.getTarget());
        System.out.println("-------------退出后置通知-----------");
    }

}

5、SpringBoot中的环绕通知

环绕通知

@Around

@Around("切入点表达式")
public void myAround(){
  //目标方法执行之前执行
  //调用目标方法 放行 让目标方法去执行
  //目标方法执行之后执行
}

//创建对象
@Component
//标识当前类式切面配置类
@Aspect
public class AspectConfig{
 @Around("execution(* com.baizhi.service.*ServiceImpl.*(..))")
    public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("-------目标方法执行之前执行的内容------");
        //放行 执行目标方法
        Object proceed = proceedingJoinPoint.proceed();
        System.out.println("方法对象：" + proceedingJoinPoint.getSignature());
        System.out.println("参数：" + proceedingJoinPoint.getArgs());
        System.out.println("目标对象：" + proceedingJoinPoint.getTarget());
        System.out.println("-------目标方法执行之后执行的内容------");
        return proceed;
    }