Spring框架

最新推荐文章于 2023-07-16 15:21:11 发布

bryant_yang

最新推荐文章于 2023-07-16 15:21:11 发布

阅读量226

点赞数

分类专栏：框架

本文链接：https://blog.csdn.net/qq_39536394/article/details/87476988

版权

框架专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1. 分层开发

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

2. spring 框架

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

3. spring 框架的核心思想

IOC inversion of controll (控制反转)

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

IOC

1. spring 中 IOC

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

添加spring依赖

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

编写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">

    <!-- spring 的配置  -->
</beans>

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

<bean id="userService" class="service.UserService"></bean>

使用 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 标签只会创建一个对象(单例)
可以通过配置来实现多例子

<!-- 其中  prototype是多例， singleton是单例(默认值) -->
<bean scope="prototype|singleton">

2.2 对象的生命周期方法

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

配置初始化

<bean init-method="初始化方法名">

配置销毁

<bean destroy-method="销毁方法名">

2.3 控制懒惰初始化

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

<bean lazy-init="true">
<!-- 全局配置 -->
<beans default-lazy-init="true">

2.4 对象之间的依赖关系

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

<bean id="userService">
    <!-- property 标签用来给对象的属性赋值 name="属性名" ref="引用id" -->
    <property name="userDao" ref="userDao"/>
</bean>

<bean id="userDao">
</bean>

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

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

3. 依赖注入

3.1 依赖注入的两种方式

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

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

常见的方式：

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

<property name="属性名" ref="引用id"/>

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

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

3.2 简化注入的办法

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

<!-- 根据属性名字查找容器中的bean，找到了就进行依赖注入, 可以唯一确定容器中的bean -->
<bean autowire="byName">
</bean>

<!-- 根据属性类型查找容器中的bean，找到了就进行依赖注入, 如果容器中有多个类型相同的bean， byType就不适用了 -->
<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">

 <!-- 启用 @Autowired 等注解 -->
    <context:annotation-config></context:annotation-config>
 	...
</beans>

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

3.3 值注入

可以使用

<property name="属性名" value="值" />
<constructor-arg index="下标" value="值"/>

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

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

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

4实际例子

4.1 spring 管理连接池

<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="username" value="root"/>
    <property name="password" value="root"/>
    <property name="maxActive" value="10"/>
    <property name="minIdle" value="2"/>
</bean>

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

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

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

    <!-- 启用注解： @Autowired @Component ... -->
    <!--<context:annotation-config></context:annotation-config>-->

    <!-- 缩小搜索范围，让spring更快找到要搜索的类
      扫描加了 @Component 注解的类， 把加了此注解的类交给 spring 管理

      base-package="起始包名1,起始包名2..."

      component-scan 里面涵盖了 annotation-config 的功能，所以可以省略前面的配置
    -->
    <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 (重点)

添加相关依赖

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

<!-- druid 连接池 依赖 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.13</version>
</dependency>

<!-- hikari 连接池 依赖 -->
<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>3.3.1</version>
</dependency>

<!-- mysql 数据库驱动 -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>

<!-- mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.6</version>
</dependency>

<!-- mybatis 与 spring 整合 -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>

<!-- 添加了 spring 对 jdbc 以及 transaction（tx） -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>4.3.22.RELEASE</version>
</dependency>

把 mybatis 中 sqlSessionFactory 交给 spring 管理

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
    <!-- 把连接池对象，依赖注入给 SqlSessionFactoryBean 的dataSource 属性 -->
    <property name="dataSource" ref="dataSource"/>
</bean>

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

<!--
一个接口，一个接口配置，比较麻烦
<bean id="heroDao" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.westos.dao.HeroDao"/>
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>-->

<!-- 扫描 有哪些 mapper 接口需要交给 spring 管理

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

使用 mapper 接口
可以直接用 context.getBean(mapper接口.class) 来获取
日志配置
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框架来讲)

<bean id="aaa" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>

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. 使用步骤

添加 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>

编写切面类

@Aspect
public class 切面类 {

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

}

把切面类和目标类都交给 spring 容器管理
可以用 <context:component-scan> 配合 @Component @Service 等注解扫描
也可以使用 <bean>
使用切面
从容器 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. 面向切面的应用

spring 中的事务管理

@Transactional
public void deleteByIds(List<Integer> ids) {

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

统一的权限控制
缓存的控制
统一的日志记录

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

bryant_yang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring框架

1. 分层开发表现层直接和用户打交道，大部分跟界面有关（html，jsp，servlet）服务层指业务逻辑，业务逻辑由一个到多个基本的增删改查组成持久层（数据访问层）将数据永久的保存，jdbc，mybatis2. spring 框架将其他框架进行整合，便于开发，提高程序的扩展性声明式的事务管理就是指不需要编写代码进行事务控制了，可以 xml 配置文件，或...
复制链接

扫一扫