Spring框架

川长思鸟来 2022-03-19 11:40 199阅读 0赞

# 1. 分层开发 #

*  表现层
    
     *  直接和用户打交道，大部分跟界面有关（html，jsp，servlet）
 *  服务层
    
     *  指业务逻辑，业务逻辑由一个到多个基本的增删改查组成
 *  持久层（数据访问层）
    
     *  将数据永久的保存，jdbc，mybatis

# 2. spring 框架 #

*  将其他框架进行整合，便于开发，提高程序的扩展性
 *  声明式的事务管理  
    就是指不需要编写代码进行事务控制了，可以 xml 配置文件，或是用注解实现事务控制
 *  编程式的事务管理  
    connection.setAutoCommit(false);  
    connection.commit();  
    connection.rollback();

# 3. spring 框架的核心思想 #

1.  IOC inversion of controll (控制反转)
    
    所谓的控制反转，就是把对象的一些控制权（对象的创建、一些方法的调用）都交给容器来完成。  
    以后可以把很多对象的控制权交给 spring 容器来管理，包括对象的创建、对象的生命周期、对象的个数、对象的依赖关系
2.  AOP aspect oriented programming (面向切面编程)  
    OOP object oriented programming (面向对象编程)

# IOC #

# 1. spring 中 IOC #

*  DI 依赖注入  
    建立对象之间依赖关系的过程

1.  添加spring依赖

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.22.RELEASE</version>
    </dependency>

1.  编写spring的配置文件  
    提供一个 xml 的配置文件，放在 main/resources 下

<?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">
    
        
    </beans>

1.  编写一个java 类交给spring容器管理  
    使用了一个 bean 标签把某个类交给spring容器管理

1.  使用 userService

// 1. 创建 spring 容器
    // 类路径（对maven项目 java 和 resources) application 应用程序 context 容器
    ClassPathXmlApplicationContext context =
            new ClassPathXmlApplicationContext("spring.xml");
    
    // 2.1 根据 id 获取容器中的对象
    UserService service = (UserService)
            context.getBean("userService");
    
    // 2.2 根据 类型 获取容器中的对象
    UserService service2 = context.getBean(UserService.class);
    
    // 原来的手段：
    // UserService service3 = new UserService();
    
    // 3. 使用对象
    service.insert(new User());

# 2. spring 容器控制反转都能控制哪些方面 #

## 2.1 对象的个数 ##

默认情况下，spring 中的每个 bean 标签只会创建一个对象(单例)  
可以通过配置来实现多例子

<bean scope="prototype|singleton">

## 2.2 对象的生命周期方法 ##

*  对于单例对象来讲，容器一创建，就会创建这些单例对象，并且随后就调用他们的初始化方法, 并且容器 close 时，会调用他们的销毁方法
 *  每次使用多例时，就会创建新的对象，并调用他们的初始化方法，多例对象不会调用销毁方法

配置初始化

配置销毁

## 2.3 控制懒惰初始化 ##

默认是false（非懒惰）, 改为 true 表示（懒惰）

## 2.4 对象之间的依赖关系 ##

例如，管理 service 和 dao 之间的依赖关系

记得要给属性提供一个 公共的 setter 方法

降低耦合度：层与层之间，要依赖接口，而不要依赖于具体实现；配合 spring 的控制反转真正实现低耦合

# 3. 依赖注入 #

## 3.1 依赖注入的两种方式 ##

DI (dependency inject) - 建立对象之间依赖关系的过程和方式

把userService 需要的 userDao 注入给 userService 的属性

常见的方式：

*  set 方法注入，spring调用set方法来完成对属性的赋值

*  构造方法注入，spring调用构造构造方法完成对属性的赋值

<constructor-arg index="下标" ref="引用id"/>

## 3.2 简化注入的办法 ##

*  autowired 自动注入 - 要么根据名字匹配， 要么根据类型匹配

<bean autowire="byName">
    </bean>
    
    
    <bean autowire="byType">
    </bean>

*  注解方式的注入  
    修改xml文件

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" 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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd" default-lazy-init="true">
    
     
        <context:annotation-config></context:annotation-config>
     	...
    </beans>

@Autowired 可以加在要注入的属性上，也可以加在属性对应的set方法或构造方法上，底层根据 byType 进行匹配注入

## 3.3 值注入 ##

可以使用

注解值注入  
@Value(“值”) – 不推荐直接给值  
@Value("$\{key\}") – 引用外部配置文件（\*.properties）中的值, 根据这个key 到 properties 文件中找相应的值

需要在spring.xml 中配置此 properties 文件

<context:property-placeholder location="classpath:文件的位置" file-encoding="utf-8"/>

# 4实际例子 #

# 4.1 spring 管理连接池 #

HikariCP 国外的 - 速度  
Druid 阿里的 - 为监控sql  
HikariDataSource

# 5. 简化控制反转 (重点) #

(spring 2.5开始), 提供了注解方式的控制反转和依赖注入

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

@Component 加在类上，spring 扫描到它之后，就把它交给 spring 容器管理

@Controller(表现层或叫控制层), @Service(业务逻辑层或叫服务层), @Repository(对应数据访问层), @Component(不属于前3层，不好分类时)

*  控制单例多例子: @Scope(“singleton|prototype”)
 *  控制初始化和销毁方法：@PostConstruct 用来标记初始化方法， @PreDestroy 用来标记销毁方法
 *  控制懒惰初始化: @Lazy 加在类上，表示这个类在容器中是懒惰初始化的

注解方式的缺点在于，不能管理第三方的 class ，例如连接池等

# 6. 结合 mybatis (重点) #

1.  添加相关依赖

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.22.RELEASE</version>
    </dependency>
    
    
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.13</version>
    </dependency>
    
    
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
        <version>3.3.1</version>
    </dependency>
    
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.6</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>1.3.2</version>
    </dependency>
    
    
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>4.3.22.RELEASE</version>
    </dependency>

1.  把 mybatis 中 sqlSessionFactory 交给 spring 管理

1.  把 mybatis 中 的 接口mapper 交给 spring 容器管理

<bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.westos.dao"/>
    </bean>

1.  使用 mapper 接口  
    可以直接用 `context.getBean(mapper接口.class)` 来获取
2.  日志配置  
    pom.xml中添加日志相关的依赖

<dependency>
        <groupId>ch.qos.logback</groupId>
        <artifactId>logback-classic</artifactId>
        <version>1.2.3</version>
    </dependency>
    
    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>jcl-over-slf4j</artifactId>
        <version>1.7.2</version>
    </dependency>
    
    <dependency>
        <groupId>commons-logging</groupId>
        <artifactId>commons-logging</artifactId>
        <version>1.2</version>
        <scope>provided</scope>
    </dependency>

提供 main/resources/logback.xml 配置文件

# 7. 声明式事务 (重点) #

启用事务注解 让 @Transactional 注解生效

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd" >
    <tx:annotation-driven/>

jdbc中  
connection.commit();  
connection.rollback();

mybatis中  
sqlSession.commit();  
sqlSession.rollback();

选择事务管理器  
事务管理器类，它来负责具体的事务管理操作（commit, rollback…)

*  DataSourceTransactionManager (对mybatis 来讲,选这个实现)
 *  HibernateTransactionManager (对hibernate框架来讲)

spring 中如果 @Transactional 的方法出现了 RuntimeException 或 Error ， 事务回滚  
@Transactional 的方法出现了 Exception 事务提交  
如果希望遇到 Exception 也回滚事务 @Transational(rollbackFor=要回滚的异常类.class)

## 7.1 @Transactional的相关配置 (了解) ##

*  readOnly 只读事务 - 如果事务内没有增删改操作，只有查询操作，可以把事务设置为 readOnly=true，能提高一些性能  
    如果在只读事务内执行增删改会报异常
 *  timeout 事务的超时时间 2ms, 一旦事务运行超过了这个时间，就会结束事务，并回滚  
    update where id=1 1ms  
    update where id=2 1ms  
    update where id=3 1ms  
    rollback;  
    超时时间的意义在于防止某个长时间运行的事务影响整个系统的性能，事务越短越好
 *  isolation 隔离级别 (隔离级别越高，一致性越好，但性能越差)
    
     *  未提交读 - 脏读、不可重复读、幻读
     *  提交读 - 不可重复读、幻读 (oracle, sqlserver…)
     *  可重复读 - 幻读 (mysql默认)
     *  序列化读 - 没有上面的问题
 *  propagation 传播行为
    
     *  Propagation.REQUIRED 必须的，如果没有事务那么开始事务，如果有事务就加入 (默认的)
     *  Propagation.SUPPORTS 支持的, 不会主动开始事务，但是会加入已经存在的事务
     *  Propagation.REQUIRES\_NEW 需要新的， 每次都会开始新事务

@Service
    class ServiceA { 
        @Transactional(propagation=Propagation.REQUIRES_NEW)  // tx1
        public void m1() { 
            m2();
        }
    }
    
    @Service
    class ServiceB { 
        @Transactional(propagation=Propagation.REQUIRES_NEW) // tx2
        public void m2() {  
    
        }
    }

# 二 AOP #

# 动态代理技术 #

*  UserServiceTarget 目标类 实现了UserService
 *  TimeHandler 包含了重复代码，间接调用目标
 *  UserServiceProxy 代理类 实现了UserService

原始编写java 代码的方式  
\*.java -> javac -> \*.class -> 类加载  
动态代理  
\*.class -> 类加载

# 1. spring 中的面向切面编程 #

AOP (aspect切面 oriented 面向 programming 编程)

切面 aspect = 通知 adivce + 切点 pointcut

通知：是一个方法，其中包含了重复的逻辑（计时，事务）  
切点：是一种匹配条件, 与条件相符合的目标方法，才会应用通知方法

代理：proxy  
目标：target

# 2. 使用步骤 #

1.  添加 maven 依赖

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>4.3.22.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.8.13</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.13</version>
    </dependency>

1.  编写切面类

@Aspect
    public class 切面类 { 
    
        @Around("切点表达式") // 切点表达式用来匹配目标和通知
        public Object 通知方法(ProceedingJoinPoint pjp) { 
            // 写一些重复的逻辑, 计时, 事务控制，权限控制
            // 调用目标 , 其中 result 是目标方法返回的结果
            Object result = pjp.proceed();
            return result;
        }
    
    }

1.  把切面类和目标类都交给 spring 容器管理  
    可以用 `<context:component-scan>` 配合 @Component @Service 等注解扫描  
    也可以使用 `<bean>`
2.  使用切面  
    从容器 getBean 根据接口获取，容器返回代理对象，代理对象中进行切点匹配，匹配到了执行通知，通知内部间接调用目标

// 1. 偷梁换柱, spring 容器返回的是一个代理对象
    UserService userService = context.getBean(UserService.class);
    
    System.out.println(userService.getClass());
    
    // 2. 调用的是代理对象的 a 方法
    userService.a();

# 3. 切点表达式 #

## 3.1 within 匹配类中的所有方法（粒度粗） ##

语法:

within(包名.类名)

UserServiceTarget  
insert  
update  
OrderServiceTarget  
a  
b  
c  
within(service.\*ServiceTarget) // 其中 \* 表示所有

## 3.2 execution 表达式 可以精确到类中的每个方法 (粒度细) ##

语法:

execution(访问修饰符 返回值 包名.类名.方法名(参数信息))

返回值的位置写 \* 表示返回值得类型是任意的  
类名 写 \* 代表任意的类  
方法名中出现 \*， 例如下面的表达式会匹配所有以 find 开头的方法

@Around("execution(public * service.UserService.*a())")

但是 \* 写在参数位置，只能匹配一个任意类型的参数

@Around("execution(public * service.UserService.a(*))")

a(int) 匹配  
a(long) 匹配

a(int, int) 不匹配  
a() 不匹配

… 写在参数位置, 匹配任意个数和任意类型的参数

@Around("execution(public * service.UserService.a(..))")

a(int) 匹配  
a(long) 匹配  
a(int, int) 匹配  
a() 匹配

## 3.3 @annotation ##

语句：

@annotation(包名.注解名)

看执行方法上有没有这个注解，有的话就算匹配

# 4. 通知类型 #

@Around - 环绕通知 （功能最强大, 可以自由定义通知代码的位置）  
@Before - 前置通知  
@After - 后置通知  
@AfterReturning - 正常返回通知  
@AfterThrowing - 异常返回通知

这几种通知实际上对应的就是通知代码相对于目标代码的位置  
@Before - 前置通知  
try \{  
目标方法  
@AfterReturning - 正常返回通知  
\} catch(Exception e) \{  
@AfterThrowing - 异常返回通知  
\} finally \{  
@After - 后置通知  
\}

# 5. 面向切面的应用 #

1.  spring 中的事务管理

@Transactional
    public void deleteByIds(List<Integer> ids) { 
    
    }
    // 代理对象.deleteByIds, 代理对象中与@Transactional进行匹配，发现方法上有这个注解，就调用事务通知, 继续调用目标方法
    // TransactionInterceptor(跟事务相关的通知代码)

1.  统一的权限控制
2.  缓存的控制
3.  统一的日志记录

# 6. spring 中如果目标类没有实现接口 #

*  如果目标对象实现了接口：底层 spring 会调用 jdk的动态代理技术 来生成代理, 要求代理对象和目标对象实现共同的接口
 *  如果目标对象没有实现接口：底层 spring 会调用 cglib 代理技术 来生成代理，生成了一个子类作为代理对象

# 7. spring 中的单元测试 #

依赖

<dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-test</artifactId>
                <version>4.3.22.RELEASE</version>
                <scope>test</scope>
            </dependency>

@RunWith(SpringJUnit4ClassRunner.class) // 让单元测试类 支持 spring
    @ContextConfiguration("classpath:spring.xml") // 指定spring配置文件的位置, 让测试类运行时根据此文件创建 spring 容器
    public class TestSpring{ 
    
        // 要测试哪个类, 然后就把这个类当做是属性, 用 @Autowired 依赖注入
        @Autowired
        private UserService userService;
    
        @Test
        public void test1() { 
            userService.b();
        }
    
        @Test
        // @Transactional 加在测试方法上，会导致执行完毕后会回滚
        public void test2() { 
            userService.a();
        }
    }