Spring

即将开始的Spring框架

是springboot的基础。

什么是Spring？

Spring是一个整合其他框架的框架。

1.IoC控制反转 Inversion of Control

• 创建对象的任务从程序员交给用户。
• 程序员提供方法。

2.Spring的配置：

1. 在IDEA中创建一个maven项目

2. 在pom.xml中添加Spring

       <dependencies>
           <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-webmvc</artifactId>
               <version>5.3.23</version>
           </dependency>
   
       </dependencies>
   

3.bean的设置

1. 先创建一个bean类：

   package com.pojo;/*
    *Author:Litao
    *Created in:
    */
   
   public class Hello {
       private String name;
   
       public String getName() {
           return name;
       }
   
       public void setName(String name) {
           this.name = name;
       }
   
       @Override
       public String toString() {
           return "Hello{" +
                   "name='" + name + '\'' +
                   '}';
       }
   }
   
   

2. 创建beans.xml文件，配置：(setter注入，必须要有无参构造方法)

   <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   
       <bean id="litao" class="com.pojo.Hello">
           <property name="name" value="LapTop" ></property>
       </bean>
   
       <bean id="desktop" class="com.pojo.Hello">
           <property name="name" value="GTX 1070"></property>
       </bean>
   
   </beans>
   

   在IDEA中，可以在resources目录右键选择创建SpringConfig，创建出来的xml文件就带有模板。

4.IoC创建对象的方式

1. 下标赋值 <constructor-arg index="0" value="index"></constructor-arg>

2. 类型

   <constructor-arg type="String" value="林北"></constructor-arg>
   

3. 参数名

   <constructor-arg name="name" value="nameMethod"></constructor-arg>
   

4. 引用

   <constructor-arg ref="user"></constructor-arg>
   

5.基于注解的spring IoC

1）创建对象的注解

@Component:可以创建任意对象

@Controller:专门用来创建控制器的对象（Servlet），这种对象接收用户请求，返回处理结果给客户端。

@Service:业务逻辑层对象，负责向下访问数据访问层，处理结果返回给界面层（控制器）

@Repository:数据访问层的对象，负责数据库中的增删改查所有操作。

2）依赖注入的注解

值类型的注入

@Value:简单类型

引用类型的注入

A.@Autowired:使用类型注入值，从Bean工厂搜索同源类型的对象进行注入。

注意：在有父子类的情况下，使用按类型注入，如果有多个可注入对象，此时按照名称进行二次筛选，选中与被注入对象相同名称的对象进行注入。

B.@Autowired

@Qualifier:使用名称注入值，从Bean工厂搜索相同名称的对象进行注入。

6.添加包扫描

使用注解就一定要添加包扫描

package里填包路径

<context:component-scan base-package="controller"></context:component-scan>

7.为应用指定多个spring配置文件

单个导入：

<import resource="applicationContext_controller.xml"></import>

<import resource="applicationContext_*.xml"></import>

8.面向切面编程AOP-AspectJ

1.Spring中整合的aop框架-AspectJ

AspectJ中常用的四种通知类型

1）前置通知@Before

2）后置通知@AfterReturning

3）环绕通知@Around

4）最终通知@After

（了解）定义切入点@pointcut

2.AspectJ切入点表达式

规范的公式:

execution(访问权限 方法返回值 方法声明（参数） 异常类型)

简化后的公式：

execution（方法返回值 方法声明（参数））

用到的符号：

*代表任意个任意的字符（通配符）

… 出现在方法的参数中，则代表任意参数

… 路径中代表本路径及其所有的子路径

示例：

execution(public * *(…))

execution(* set*(…))//以set打头的所有方法

execution(* com.xyz.service.impl.*.*(..)) //在任意返回值的com.xyz.service.impl包下的所有类的所有方法任意参数上添加切面的功能。

execution(* com.xyz.service..*.*(..))//任意返回值 这个路径下所有的子路径下任意类中所有方法添加切面功能

@PointCut

设置别名：

@Pointcut(value = "execution(* s1.ServiceImpl.*(..))")
    public void myCut(){}

@Before

@Before("myCut()")
    public void myBefore(JoinPoint jp){
        System.out.println("前置通知的实现");
    }

before无法获取切入方法的返回值，但是可以获取切入方法的返回类型，方法名，参数等等…

前置通知的切面方法规范

1）访问权限是public

2）方法的返回值是void

3）方法名称自定义

4）方法没有参数，或者只能是JoinPoint类型

5）必须使用@Before注解来声明切入的时机是前切

@Before参数：value 指定切入点表达式

JoinPoint

System.out.println("目标方法的签名：" + jp.getSignature());
System.out.println("目标方法的参数：" + Arrays.toString(jp.getArgs()));

获取方法的签名和参数列表。

@AfterReturning

@AfterReturning(value = "myCut()",returning = "obj")
    public void myReturning(Object obj){
        System.out.println("后置通知的实现");
    }

需要传入参数，是方法的返回值，如果没有返回值可以不填参数。

参数：value：指定切入点表达式

returning：指定目标方法的返回值名称。必须与切面方法中的参数名一致。

@After最终通知

@After(value = "myCut()")
    public void myAfter(){
        System.out.println("最终通知的实现");
    }

方法中出错时会继续运行业务方法和切面的内容。

9.Spring-MyBatis整合

1. 建表
2. 新建项目，选择quickstart模板
3. 修改目录
4. 修改pom.xml文件，添加相关的依赖
5. 添加MyBatis模板（SqlMapConfig.xml和XXXMapper.xml)
6. 添加SqlMapConfig.xml,并拷贝jdbc.properties属性文件
7. 添加applicationContext_mapper.xml
8. 添加applicationContext.service.xml
9. 添加Users实体类，Accounts实体类
10. 添加mapper包，添加UsersMapper接口和UsersMapper.xml文件并开发
11. 添加service包，添加UsersService接口和UsersServiceImpl实现类
12. 添加测试类进行功能测试

10.事务@Transactional参数

基于注解的事务添加步骤：

1、在applicationContext_service.xml文件中添加事务管理器

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<!--        事务必须关联数据库处理，所以要配置数据源,mybatis的事务管理器：DataSourceTransactionManager-->
<property name="dataSource" ref="dataSource"></property>
    </bean>

2、添加事务的注解驱动

<tx:annotation-driven
transaction-manager="transactionManager"></tx:annotation-driven>

@Transactional(propagation = Propagation.REQUIRED,
noRollbackForClassName = "",//异常的名称
noRollbackFor = "",//异常的类型
rollbackFor = ,
rollbackForClassName = "",
timeout = -1,
readOnly = false,
isolation = Isolation.DEFAULT
)

11.事务的传播特性

常用：

PROPAGATION_REQUIRED:增删改必用

PROPAGATION_REQUIRES_NEW:自己新开一个事务

PROPAGATION_SUPPORTS:支持事务，如果加入的方法有事务，就支持事务，如果没有，不单开事务。

PROPAGATION_NEVER:不能运行事务，如果包在事务中，抛出异常。

PROPAGATION_NOT_SUPPORT：不支持事务，运行在非事务的环境。

不常用

PROPAGATION_MANDATORY:没有事务则抛出异常

PROPAGATION_NESTED:嵌套事务

项目中的所有事务，必须添加到业务逻辑层上