Spring4_Day03

最新推荐文章于 2023-06-28 09:49:41 发布

逆风微笑代码狗I

最新推荐文章于 2023-06-28 09:49:41 发布

阅读量178

点赞数

分类专栏： SSH

本文链接：https://blog.csdn.net/weixin_43912805/article/details/103764103

版权

SSH 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章目录

Spring4_Day03

Spring4_Day03

Spring的AOP的基于Aspectj注解开发

Spring的基于AspectJ的AOP注解开发（入门）

入门案例

目标类（被增强的类）

package com.lld.Spring.demo01;

/**
 * 被增强的类:目标类
 * @author Administrator
 *
 */
public class OrderDao {
	public void save(){
		System.out.println("订单保存了");
	}
	public void update(){
		System.out.println("订单更新了");
	}
	public void delete(){
		System.out.println("订单删除了");
	}
	public void find(){
		System.out.println("订单查找了");
	}
}

切面类（增强的类）

package com.lld.Spring.demo01;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

/**
 * 切面类:使用注解开发
 * @author Administrator
 *
 */

@Aspect		//表名该类是增强类
public class MyAspectAnno {

	//Before代表前置增强:value里面写execution表达式(跟xml配置相同)
	@Before(value="execution(* com.lld.Spring.demo01.OrderDao.save(..))")
	public void before(){
		System.out.println("前置增强............");
	}
}

配置文件

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置开启注解开发 -->
	<aop:aspectj-autoproxy />
	
	<!-- 被增强的类:目标类 -->
	<bean id="OrderDao" class="com.lld.Spring.demo01.OrderDao" />
	
	<!-- 增强的类:切面类 -->
	<bean id="MyAspectAnno" class="com.lld.Spring.demo01.MyAspectAnno" />
	
</beans>

测试类（开启了Junit整合开发）

package com.lld.Spring.demo01;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 测试类:开启了Junit开发
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class demo {
	
	@Resource(name="OrderDao")
	private OrderDao Order;
	
	@Test
	public void demo01(){
		Order.delete();
		Order.update();
		Order.save();
		Order.find();
	}
}

Spring的注解AOP的通知类型

@Before：前置通知
@AfterReturning：后置通知
@Around：环绕通知
AfterThrowing：异常抛出通知
@After：最终通知

package com.lld.Spring.demo01;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;

/**
 * 切面类:使用注解开发
 * @author Administrator
 *
 */

@Aspect		//表名该类是增强类
public class MyAspectAnno {

	//Before代表前置增强:value里面写execution表达式(跟xml配置相同)
	@Before(value="execution(* com.lld.Spring.demo01.OrderDao.save(..))")
	public void before(){
		System.out.println("前置增强............");
	}
	@Around(value="execution(* com.lld.Spring.demo01.OrderDao.find(..))")
	public Object Around(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("环绕增强前............");
		Object obj = joinPoint.proceed();
		System.out.println("环绕增强后............");
		
		return obj;
	}
	@AfterThrowing(value="execution(* com.lld.Spring.demo01.OrderDao.update(..))",throwing="ex")
	public void AfterThrowing(Throwable ex){
		System.out.println("异常抛出增强............"+ex.getMessage());
	}
	@AfterReturning(value="execution(* com.lld.Spring.demo01.OrderDao.delete(..))",returning="result")
	public void AfterReturning(Object result){
		System.out.println("后置增强............"+result);
	}
}

Spring的注解的AOP的切入点的配置

package com.lld.Spring.demo01;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;

/**
 * 切面类:使用注解开发
 * @author Administrator
 *
 */

@Aspect		//表名该类是增强类
public class MyAspectAnno {

	//Before代表前置增强:value里面写execution表达式(跟xml配置相同)
	@Before(value="MyAspectAnno.pointcut2()")
	public void before(){
		System.out.println("前置增强............");
	}
	@Around(value="MyAspectAnno.pointcut4()")
	public Object Around(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("环绕增强前............");
		Object obj = joinPoint.proceed();
		System.out.println("环绕增强后............");
		return obj;
	}
	@AfterThrowing(value="MyAspectAnno.pointcut3()",throwing="ex")
	public void AfterThrowing(Throwable ex){
		System.out.println("异常抛出增强............"+ex.getMessage());
	}
	@AfterReturning(value="MyAspectAnno.pointcut1()",returning="result")
	public void AfterReturning(Object result){
		System.out.println("后置增强............"+result);
	}
	
	@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.delete(..))")
	private void pointcut1(){}
	@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.save(..))")
	private void pointcut2(){}
	@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.update(..))")
	private void pointcut3(){}
	@Pointcut(value="execution(* com.lld.Spring.demo01.OrderDao.find(..))")
	private void pointcut4(){}	
}

Spring的JDBC模板的使用

Spring的JDBC模板

Spring是EE开发的一站式的框架，有EE开发的每层的解决方案。Spring对持久层也提供了解决方案：ORM模块和JDBC的模板。
Spring提供了很多的模板用于简化开发：

Spring的JDBC模板使用入门

创建项目
引入jar包
- 基本开发包
- 数据库驱动
- Spring的JDBC模板
创建数据库

CREATE DATABASE Spring4_Day03_JDBC;
USE Spring4_Day03_JDBC;
CREATE TABLE account(
	id INT PRIMARY KEY AUTO_INCREMENT,
	NAME VARCHAR(20),
	money DOUBLE
);

使用JDBC模板保存数据

package com.lld.Spring.JDBC;

import org.junit.Test;


import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

public class JDBCDemo {

	@Test
	public void demo01(){
		//创建连接池
		DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
		//设置连接驱动
		driverManagerDataSource.setDriverClassName("com.mysql.jdbc.Driver");
		//设置uri
		driverManagerDataSource.setUrl("jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC");
		//设置用户名
		driverManagerDataSource.setUsername("root");
		//设置密码
		driverManagerDataSource.setPassword("1");
		//创建JDBC模板
		JdbcTemplate jdbcTemplate = new JdbcTemplate(driverManagerDataSource);
		//进行保存
		jdbcTemplate.update("insert into account values(null,?,?)","曲秃秃",250d);
	}
}

将连接池和模板交给Spring管理

引入Spring的配置文件并进行配置

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Spring的内置的连接池======================== -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC"/>
		<property name="username" value="root"/>
		<property name="password" value="1"/>
	</bean>
	
	
	<bean id="JdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="DataSource" ref="dataSource"></property>
	</bean>
	
</beans>

引入spring_aop的jar包
使用JDBC模板

package com.lld.Spring.JDBC;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JDBCDemo2 {
	
	@Resource(name="JdbcTemplate")
	private JdbcTemplate jdbcTemplate;
	
	@Test
	public void demo01(){
		jdbcTemplate.update("insert into account values(null,?,?)","666",100d);
	}
}

使用开源的数据库连接池

DBCP的使用

配置数据库连接池

<!-- 配置DBCP连接池 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC"/>
		<property name="username" value="root"/>
		<property name="password" value="1"/>
	</bean>

C3P0的使用

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"/>
		<property name="jdbcUrl" value="jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC"/>
		<property name="user" value="root"/>
		<property name="password" value="1"/>
	</bean>

抽取配置到属性文件

<!-- 引入属性文件================================== -->
	<!-- 第一种方式通过一个bean标签引入的（很少） -->
<!-- 	<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="classpath:jdbc.properties"/>
	</bean> -->
	
	<!-- 方式二 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://39.106.68.251/Spring4_Day03_JDBC
jdbc.username=root
jdbc.password=1

使用JDBC模板完成CRUD操作

保存操作
修改操作
删除操作
查询操作

package com.lld.Spring.JDBC;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.lld.Spring.domain.account;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JDBCDemo2 {
	
	@Resource(name="JdbcTemplate")
	private JdbcTemplate jdbcTemplate;
	
	/**
	 * 插入操作
	 */
	@Test
	public void demo01(){
		jdbcTemplate.update("insert into account values(null,?,?)","888",100d);
	}
	
	/**
	 * 删除操作
	 */
	@Test
	public void demo02(){
		jdbcTemplate.update("delete from account where id=?",1);
	}
	
	/**
	 * 修改操作
	 */
	@Test
	public void demo03(){
		jdbcTemplate.update("update account set name=? where id=?",123,5);
	}
	
	/**
	 * 统计操作
	 */
	@Test
	public void demo04(){
		Long forObject = jdbcTemplate.queryForObject("select count(*) from account", Long.class);
		
		System.out.println(forObject);
	}
	
	/**
	 * 查询单个值
	 */
	
	@Test
	public void demo05(){
		String forObject = jdbcTemplate.queryForObject("select name from account where id=2",String.class);
		System.out.println(forObject);
	}
	
	/**
	 * 查询一个对象
	 */
	
	@Test
	public void demo06(){
		account query = jdbcTemplate.queryForObject("select * from account where id=?", new MyrowMapper(),6);
		System.out.println(query);
	}
	
	/**
	 * 查询多个对象
	 */
	public void demo07(){
		List<account> list = jdbcTemplate.query("select * from account", new MyrowMapper());
		for (account account : list) {
			System.out.println(account);
		}
	}
	
	
	class MyrowMapper implements RowMapper<account>{

		@Override
		public account mapRow(ResultSet rSet, int rowNum) throws SQLException {
			account account = new account();
			account.setId(rSet.getInt("id"));
			account.setName(rSet.getString("name"));
			account.setMoney(rSet.getDouble("money"));
			return account;
		}
		
	}
}

Spring的事务的管理

事务回顾

什么是事务

事务：逻辑上的一组操作，组成这组操作的各个单元要么全部成功要么全部失败。

事务的特性

一致性：事务执行前后数据完整性保持一致
隔离性：一个事务的执行不应该受到其他事务的干扰
原子性：事务不可分割
持久性：一旦事务结束，数据持久化到数据库

如果不考虑隔离性引发的安全性的问题

读问题
- 脏读：一个事务读到另一个事物未提交的数据
- 不可重复读：一个事务读到另一个事务update的数据，导致一个事务多次查询结果不一致
- 幻读、虚读：一个事务读到另一个事务已经提交的insert的数据，导致一个事务中多查询结果不一致
写问题
- 丢失更新

解决读问题

设置事务的隔离级别
- Read uncommitted：读未提交，任何问题解决不了
- Read committed：读已提交，解决脏读，但是不可重复读和虚读有可能发生
- Repeatable read ：重复读，解决脏读和不可重复读，但是虚读有可能发生。
- Serializable ：解决所有读问题。

Spring的事务管理的API

PlatformTransactionManager：平台事务管理器

平台事务管理器：接口，是Spring用于管理事务的真正的对象。
DataSourceTransactionManager ：底层使用JDBC管理事务
HibernateTransactionManager ：底层使用Hibernate管理事务

TransactionDefinition ：事务定义信息

事务定义：用于定义事务的相关的信息，隔离级别、超时信息、传播行为、是否只读

TransactionStatus：事务的状态

事务状态：用于记录在事务管理过程中，事务的状态的对象。

事务管理的API的关系：

Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在事务管理过程中，产生各种状态，将这些状态的信息记录到事务状态的对象中。

Spring的事务的传播行为

在这里插入图片描述

Spring中提供了七种事务的传播行为：

保证多个操作在同一个事务中

PROPAGATION_REQUIRED ：默认值，如果A中有事务，使用A中的事务，如果A没有，创建一个新的事务，将操作包含进来
PROPAGATION_SUPPORTS ：支持事务，如果A中有事务，使用A中的事务。如果A没有事务，不使用事务。
PROPAGATION_MANDATORY ：如果A中有事务，使用A中的事务。如果A没有事务，抛出异常。

保证多个操作不在同一个事务中

PROPAGATION_REQUIRES_NEW ：如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。如果A中没有事务，创建一个新事务，包含自身操作。
PROPAGATION_NOT_SUPPORTED ：如果A中有事务，将A的事务挂起。不使用事务管理。
PROPAGATION_NEVER ：如果A中有事务，报异常。

嵌套式事务

PROPAGATION_NESTED ：嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点。

事务的管理（编码式）

配置平台事务管理器
使用Spring提供的事务管理模板类
在业务层注入事务管理模板
编写事务管理代码

事务管理（声名式）

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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Service============= -->
	<bean id="accountService" class="com.itheima.tx.demo2.AccountServiceImpl">
		<property name="accountDao" ref="accountDao"/>
	</bean>
	
	<!-- 配置DAO================= -->
	<bean id="accountDao" class="com.itheima.tx.demo2.AccountDaoImpl">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<!-- 配置连接池和JDBC的模板 -->
	<!-- 第二种方式通过context标签引入的 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置C3P0连接池=============================== -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- 配置事务管理器=============================== -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<!-- 配置事务的增强=============================== -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<!-- 事务管理的规则 -->
			<!-- <tx:method name="save*" propagation="REQUIRED" isolation="DEFAULT"/>
			<tx:method name="update*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
			<tx:method name="find*" read-only="true"/> -->
			<tx:method name="*" propagation="REQUIRED" read-only="false"/>
		</tx:attributes>
	</tx:advice>
	
	<!-- aop的配置 -->
	<aop:config>
		<aop:pointcut expression="execution(* com.itheima.tx.demo2.AccountServiceImpl.*(..))" id="pointcut1"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
	</aop:config>
</beans>

注解方式

<?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:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	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/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Service============= -->
	<bean id="accountService" class="com.itheima.tx.demo3.AccountServiceImpl">
		<property name="accountDao" ref="accountDao"/>
	</bean>
	
	<!-- 配置DAO================= -->
	<bean id="accountDao" class="com.itheima.tx.demo3.AccountDaoImpl">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<!-- 配置连接池和JDBC的模板 -->
	<!-- 第二种方式通过context标签引入的 -->
	<context:property-placeholder location="classpath:jdbc.properties"/>
	
	<!-- 配置C3P0连接池=============================== -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"/>
		<property name="jdbcUrl" value="${jdbc.url}"/>
		<property name="user" value="${jdbc.username}"/>
		<property name="password" value="${jdbc.password}"/>
	</bean>
	
	<!-- 配置事务管理器=============================== -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>
	
	<!-- 开启注解事务================================ -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

在要是用事务的类上添加注解@Transactional

package com.itheima.tx.demo3;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

/**
 * 转账的业务层的实现类
 * @author jt
 *
 */
@Transactional(isolation=Isolation.DEFAULT,propagation=Propagation.REQUIRED)
public class AccountServiceImpl implements AccountService {

	// 注入DAO:
	private AccountDao accountDao;
	
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}
	
	@Override
	/**
	 * from：转出账号
	 * to：转入账号
	 * money：转账金额
	 */
	public void transfer( String from,  String to,  Double money) {
		
			accountDao.outMoney(from, money);
			int d = 1/0;
			accountDao.inMoney(to, money);
		
	}

}