Spring学习笔记(4)

阅读数: 次 2021-02-25

文章导航

Spring学习笔记

🦋🦋🦋

AOP增强，JdbcTemplate,事务

AOP增强

一. AOP增强简介

Spring使用增强类定义横切逻辑，同时由于Spring只支持方法连接点，增强类还包括在方法的哪一点加入横切代码的方位信息，所以增强既包含横切逻辑，又包含部分连接点信息。

其中带Spring标志的是Spring定义的扩展增强接口,带aopalliance标志的是AOP联盟所定义的接口。

二. AOP增强类型

按照增加在目标类方法连接点的位置可以将增强划分为以下五类：

前置增强 (org.springframework.aop.BeforeAdvice) 表示在目标方法执行前来实施增强。
后置增强 (org.springframework.aop.AfterReturningAdvice) 表示在目标方法执行后来实施增强。
环绕增强 (org.aopalliance.intercept.MethodInterceptor) 表示在目标方法执行前后同时实施增强。
异常抛出增强 (org.springframework.aop.ThrowsAdvice) 表示在目标方法抛出异常后来实施增强。
引介增强 (org.springframework.aop.introductioninterceptor) 表示在目标类中添加一些新的方法和属性。

引介增强是一种特殊的增强。他可以在目标类中添加属性和方法，通过拦截定义一个接口，让目标代理实现这个接口。他的连接点是类级别的，而前面的几种则是方法级别的。环绕增强是AOP联盟定义的接口，其他四种增强接口则是Spring定义的接口。

AOP增强：通过实现这些增强接口，在实现这些接口的方法当中定义横切逻辑，然后通过配置Spring的配置文件就可以完成将增强织入到目标方法当中了。

三.AOP增强实现

1). 前置增强

@Controller
public class MyBeforeAdvice implements MethodBeforeAdvice{

	@Override
	public void before(Method method, Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("----------开始日志----------");
		System.out.println("类名："+target.getClass().getSimpleName());
		System.out.println("[前置通知]方法名："+method.getName()+",参数："+args[0]);
	}
}

2). 后置返回增强

@Controller
public class MyAfterAdvice implements AfterReturningAdvice{

	@Override
	public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("----------结束日志----------");
		System.out.println("[后置返回通知]方法名："+method.getName()+",参数："+args[0]);
		System.out.println("返回值："+returnValue);
	}
	
}

3). 环绕增强

@Controller
public class MyAroundAdvice implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		// TODO Auto-generated method stub
		Object obj = null;
		System.out.println("---------开始事务----------");
		obj = invocation.proceed();//拦截器的放行
		System.out.println("---------结束事务----------");
		return obj;
	}
}

4). 异常抛出增强

@Controller
public class MyThrowAdvice implements ThrowsAdvice {

	public void afterThrowing(RuntimeException ex) throws Throwable{
		System.out.println("[异常通知]:-----抛出的异常是:"+ex+"-----");
	}
}

JdbcTemplate

一. 简介

1). 为了使JDBC更加易于使用，Spring在JDBC API上定义了一个抽象层，以此建立一个JDBC存取框架。

2). 作为Spring JDBC框架的核心，JDBC模板的设计目的是为不同类型的JDBC操作提供模板方法，通过这种方式，可以在尽可能保留灵活性的情况下，将数据库存取的工作量降到最低。

3). Spring的JdbcTemplate是一个小型的轻量级持久化层框架。

二. JdbcTemplate的使用

1). JdbcTemplate所需要的JAR包

IOC容器所需要的JAR包
	commons-logging-1.1.1.jar
	spring-beans-4.0.0.RELEASE.jar
	spring-context-4.0.0.RELEASE.jar
	spring-core-4.0.0.RELEASE.jar
	spring-expression-4.0.0.RELEASE.jar
JdbcTemplate所需要的JAR包
	spring-jdbc-4.0.0.RELEASE.jar
	spring-orm-4.0.0.RELEASE.jar
	spring-tx-4.0.0.RELEASE.jar
数据库驱动和数据源
	ojdbc6.jar
	druid-1.1.20.jar

2). 存储连接数据库信息

jdbc.driver=oracle.jdbc.OracleDriver
jdbc.url=jdbc:oracle:thin:@127.0.0.1:1521:BOOKSHOP
jdbc.username=scott
jdbc.password=123456

3). 数据库连接的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	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-4.3.xsd">
	
	<!-- 引入资源属性文件 -->
<!-- 	<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="db.properties"></property>
	</bean> -->
	<!-- 引入文件(需要开启命名空间) -->
	<context:property-placeholder location="db.properties"/>

	<!-- 创建数据源 -->	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driver}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>		
	</bean>
	
	<!-- 通过数据源配置JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
</beans>

4). 增删改查测试方法

public class TestJdbcTemplate {
	ApplicationContext ac = new ClassPathXmlApplicationContext("jdbc.xml");
	JdbcTemplate jdbcTemplate =ac.getBean("jdbcTemplate",JdbcTemplate.class);
    	
    @Test
	public void test2(){
		//查看数据
		List<Map<String, Object>> queryForList = jdbcTemplate.queryForList("select * from emp");
		for(Map map:queryForList){
			System.out.println(map);
		}
	}
	
}

① 增删改

JdbcTemplate.update(String, Object...)

//单条增删改
@Test
public void test1(){
	//查看创建的对象
	System.out.println(jdbcTemplate);
	//添加数据
	jdbcTemplate.update("insert into emp values(?,?,?,null,?,?,?,null)",8080,"特朗普","白宫",new Date(),3000,1000);
}

② 批量增删改

JdbcTemplate.batchUpdate(String, List<Object[]>)
Object[]封装了SQL语句每一次执行时所需要的参数
List集合封装了SQL语句多次执行时的所有参数

//批量增删改
@Test
public void test3(){
	//批量操作添加
	String sql = "insert into emp values(?,?,?,null,?,?,?,null)";
	List<Object[]> list = new ArrayList<>();
	list.add(new Object[]{2020,"诸葛亮","蜀",new Date(),6000,500});
	list.add(new Object[]{2021,"郭嘉","魏",new Date(),9000,200});
	list.add(new Object[]{2022,"孙权","吴",new Date(),4000,1000});
	jdbcTemplate.batchUpdate(sql,list);
}

③ 查询单行

JdbcTemplate.queryForObject(String, RowMapper<Department>, Object...)

//数据的查询
@Test
public void test4(){
	//查询数据
	String sql = "select empno,ename,job,hiredate,sal,comm from emp where empno=?";
	RowMapper<Emp> rowMapper = new BeanPropertyRowMapper<>(Emp.class);//将列名与属性名进行映射
	Emp emp = jdbcTemplate.queryForObject(sql,new Object[]{2020},rowMapper);
	System.out.println(emp);
}

④ 查询多行

JdbcTemplate.query(String, RowMapper<Department>, Object...)
RowMapper对象依然可以使用BeanPropertyRowMapper

@Test
public void test5(){
	RowMapper<Emp> rowMapper2 = new BeanPropertyRowMapper<>(Emp.class);
	List<Emp> list = jdbcTemplate.query("select empno,ename,job,hiredate,sal,comm from emp", rowMapper2);
	for(Emp em : list){
		System.out.println(em);
	}
}

⑤ 查询单一值

JdbcTemplate.queryForObject(String, Class, Object...)


@Test
public void test6(){
	Integer count = jdbcTemplate.queryForObject("select count(*) from emp", Integer.class);
	System.out.println("数据量："+count);
}

事务

一. 简介

事务就是一组由于逻辑上紧密关联而合并成一个整体(工作单元)的多个数据库操作，这些操作要么都执行，要么都不执行，保证了数据的完整性和一致性。
事务：一组业务操作ABCD，要么全部成功，要么全部不成功。

二. 特性：

1). ACID

原子性：整体
事务的原子性(不可再分)要求事务中的所有操作要么都执行，要么都不执行。
一致性：完成
所有数据都处于满足业务规则的一致性状态。如果一个事务在执行的过程中，其中某个操作失败了，则必须将其他所有操作撤销，将数据恢复到事务执行之前的状态，这就是回滚。
隔离性：并发
每个事务都应该与其他事务隔离开来，防止数据损坏。隔离性原则要求多个事务在并发执行过程中不会互相干扰。
持久性：结果
持久性原则要求事务执行完成后，对数据的修改永久的保存下来。

2). 隔离问题：

脏读：一个事务读到另一个事务没有提交的数据;
不可重复读：一个事务读到另一个事务已提交的数据（update）[读出的数据不一样];
虚读(幻读)：一个事务读到另一个事务已提交的数据（insert）[读出的数据不一样];

3). 隔离级别：

读未提交read uncommitted：允许其他事务读取未提交的数据，存在3个问题；
读已提交read committed：只能读取其他食物已提交的数据，解决脏读，存在2个问题；
可重复读repeatable read：同一事务期间可重复读取多次相同的值（其他事务提交的也读不到）,解决：脏读、不可重复读，存在1个问题；
串行化serializable：解决并发问题，性能弱，单事务；

三.Spring事务管理

1). 编程式事务管理

使用原生的JDBC API进行事务管理
[1]获取数据库连接Connection对象
[2]取消事务的自动提交
[3]执行操作
[4]正常完成操作时手动提交事务
[5]执行失败时回滚事务
[6]关闭相关资源

特点：
原生的JDBC API实现事务管理是所有事务管理方式的基石，同时也是最典型的编程式事务管理。编程式事务管理需要将事务管理代码嵌入到业务方法中来控制事务的提交和回滚。会造成较大程度的代码冗余。

2). 声明式事务

事务管理代码的固定模式作为一种横切关注点，可以通过AOP方法模块化，进而借助Spring AOP框架实现声明式事务管理。

Spring既支持编程式事务管理，也支持声明式的事务管理。

四. 事务管理器的主要实现

1). DataSourceTransactionManager：在应用程序中只需要处理一个数据源，而且通过JDBC存取。
2). JtaTransactionManager：在JavaEE应用服务器上用JTA(Java Transaction API)进行事务管理
3). HibernateTransactionManager：用Hibernate框架存取数据库

事务管理器可以在目标方法运行前后进行事务控制（事务切面）;

五. 事务初步实现

1). 配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
	
	<!-- 自动装配bean -->
	<context:component-scan base-package="com.AAA.teng"></context:component-scan>
	
	<!-- 引入资源属性文件(需要开启命名空间) -->
	<context:property-placeholder location="db.properties"/>

	<!-- 创建数据源 -->	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driver}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>		
	</bean>
	
	<!-- 通过数据源配置JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 事务控制 -->
	<!-- 配置事务管理器（切面）进行事务控制，需要导入AOP的一系列jar包 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 控制数据源 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 开启基于注解的事务控制 （tx命名空间）-->
	<tx:annotation-driven transaction-manager="transactionManager"/>
	<!-- 给事务方法添加注解:@Transactional -->
	
</beans>

2). 在方法上加事务控制

重要的用配置，不重要的用注解。

①注解`@Transactional`

@Service
public class BookServiceImpl implements BookService{

	@Autowired
	private Bookdao dao;

	/**
	 * 事务的方法
	 * isolation-Isolation:事务的隔离级别
	 * propagation-Propagation:事务的传播行为
	 * 
	 * 事务遇到运行时异常回滚，发生编译时异常不回滚。
	 * noRollbackFor-Class[]:哪些异常事务不需要回滚（运行时异常不回滚）
	 * noRollbackForClassName-String[]（String全类名）:
	 * rollbackFor-Class[]:哪些异常事务需要回滚（编译时异常回滚）
	 * rollbackForClassName-String[]（String全类名）:
	 * 
	 * readOnly-boolean:表示这个事务为只读，不更新数据；
	 * 		可以进行实物优化；
	 * 		readOnly=true:加快查询速度，只能在读取时使用；
	 * timeout-int（秒为单位）:超时，事务超出指定执行事件后自动终止并回滚
	 */
	@Transactional(timeout=5,readOnly=true,noRollbackFor={ArithmeticException.class})//事务管理器
	@Override
	public void buyBook(String bookName, String userName) {
		// TODO Auto-generated method stub
		Integer price = dao.selectPrice(bookName);
		dao.updateStock(bookName);
		dao.updateBalance(userName, price);
		//数学运算异常
		int i = 10/0;
	}
	
}

②配置文件xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">
	
	<!-- 自动装配bean -->
	<context:component-scan base-package="com.AAA.teng"></context:component-scan>
	
	<!-- 引入资源属性文件(需要开启命名空间) -->
	<context:property-placeholder location="db.properties"/>

	<!-- 创建数据源 -->	
	<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
		<property name="driverClassName" value="${jdbc.driver}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>		
	</bean>
	
	<!-- 通过数据源配置JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 事务控制 -->
	<!-- 配置事务管理器（切面）进行事务控制，需要导入AOP的一系列jar包 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 控制数据源 -->
		<property name="dataSource" ref="dataSource"></property>
	</bean>	
	
	<!-- 基于xml配置事务控制 -->
	<aop:config>
		<aop:pointcut expression="execution(* com.AAA.teng.service.*.*(..))" id="txPoint"></aop:pointcut>
		<!-- 事务建议：事务增强
			advice-ref：指向事务管理器的配置
		 -->
		<aop:advisor advice-ref="myAdvice" pointcut-ref="txPoint"/>
	</aop:config>
	
	<!-- 配置事务管理器
		transaction-manager:指定配置哪个事务管理器
	 -->
	<tx:advice id="myAdvice" transaction-manager="transactionManager">
		<!-- 配置事务属性 -->
		<tx:attributes>
			<!-- 指明哪些方法是事务方法 -->
			<tx:method name="*"/>
			<tx:method name="buyBook" propagation="REQUIRES_NEW" timeout="-1"/>
			<tx:method name="get*" read-only="true"/>
		</tx:attributes>
	</tx:advice>	
		
</beans>

3). 隔离级别

隔离级别解决并发问题的能力见下表

	脏读	不可重复读	幻读	Oracle	MySQL
READ UNCOMMITTED	有	有	有	×	√
READ COMMITTED	无	有	有	√	√
REPEATABLE READ	无	无	有	×	√（默认）
SERIALIZABLE	无	无	无	√	√

/**
 * 有事务的业务逻辑，容器中保存的是这个业务逻辑的代理对象
 * 
 * 根据实际情况选择隔离级别
 * @param bookName
 * @return
 */
@Transactional(readOnly=true,isolation=Isolation.READ_UNCOMMITTED)
public int getPrice(String bookName){
	return dao.selectPrice(bookName);
}

4). 传播行为

当事务方法被另一个事务方法调用时，必须指定事务应该如何传播。方法可能继续在现有事务中运行，也可能开启一个新事务，并在自己的事务中运行。事务的传播行为可以由传播属性指定。

@Transactional(propagation=Propagation.REQUIRES_NEW)
@Override
public void buyBook(String bookName, String userName) {
	// TODO Auto-generated method stub
	Integer price = dao.selectPrice(bookName);
	dao.updateStock(bookName);
	dao.updateBalance(userName, price);
	//数学运算异常
	int i = 10/0;
}

/**
 * propagation-Propagation:事务的传播行为
 * 	事务的传播+事务的行为
 * 		如果有多个事务进行嵌套运行，子事务是否要和大事务共用一个事务；
 *
 * 	如果使用REQUIRED的话，那么事务的属性配置都是继承大事务的设置；
 *  而REQUIRES_NEW是可以调节的。[默认是REQUIRED]
 *
 *  REQUIRED:将之前事务用的connection传递给这个方法使用；
 *  REQUIRES_NEW:这个方法直接使用使用新的connection；
 */
@Transactional(propagation=Propagation.REQUIRED)
public void updatePrice(String bookName,Integer price){
	dao.updatePrice(bookName, price);
	int i = 10/0;
}

多个事务执行

@Service
public class MulService {

	@Autowired
	private BookService bookService;
	
	
	/**
	 * 任何地方报错，已经执行的REQUIRES_NEW都会成功;
	 * 报错的地方向上映射，REQUIRES同一个事务（坐一辆车的）都回滚;
	 * 未执行的REQUIRES_NEW也会回滚;
	 */
	@Transactional
	public void mulTx(){
		//可以设置这个事务是否和之前的大事务共享一个事务
		bookService.buyBook("ISBN-001", "Tom");
		bookService.updatePrice("ISBN-002", 888);
	}
}

本文作者： 腾飞
本文链接： https://www.tengfei.eu.org/article/43bf071f.html
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！

AOP增强

一. AOP增强简介

二. AOP增强类型

三.AOP增强实现

1). 前置增强

2). 后置返回增强

3). 环绕增强

4). 异常抛出增强

JdbcTemplate

一. 简介

二. JdbcTemplate的使用

1). JdbcTemplate所需要的JAR包

2). 存储连接数据库信息

3). 数据库连接的配置文件

4). 增删改查测试方法

① 增删改

② 批量增删改

③ 查询单行

④ 查询多行

⑤ 查询单一值

事务

一. 简介

二. 特性：

1). ACID

2). 隔离问题：

3). 隔离级别：

三.Spring事务管理

1). 编程式事务管理

2). 声明式事务

四. 事务管理器的主要实现

五. 事务初步实现

1). 配置文件

2). 在方法上加事务控制

①注解@Transactional

②配置文件xml

3). 隔离级别

4). 传播行为

①注解`@Transactional`