Spring学习日记第三天—SpringAOP

于 2019-10-24 21:26:12 发布
阅读量96 收藏
点赞数
分类专栏： SpringAOP 文章标签： AOP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43460857/article/details/102729704
版权

SpringAOP

AOP介绍

AOP就是面向切面编程，他是OOP（面向对象）编程的补充和完善。
面向切面是面向对象中的一种方式而已。在执行代码的过程中动态嵌入其他代码，这就是面向切面编程。
他的本质就是动态代理

AOP并不是Spring所独有的，他是共有的，在别的一些框架中他都有体现

一、Schema-based方式实现AOP

使用前需要导入两个包
在这里插入图片描述在这里插入图片描述

1、前置通知（MethodBeforeAdvice）：目标方法执行之前调用
2、后置通知（AfterRetureningAdvice）：目标方法执行完成之后调用
3、环绕通知（MethodInterceptor）：目标方法执行前后都能调用，而且还能增强
4、异常通知（ThrowsAdvice）： 目标方法出现异常调用

具体代码实现

Service

public interface UserService {
	public String helloword(String msg);
	public void hellojava(String msg);
}

ServiceImp

public class UserServiceImp implements UserService {
	@Override
	public String helloword(String msg) {
		// TODO Auto-generated method stub
		System.out.println("传递的信息:"+msg);
		return msg;
	}
	@Override
	public void hellojava(String msg) {
		// TODO Auto-generated method stub
		System.out.println("传递的信息:"+msg);
	}
}

通知类Adviece

//前置通知
public class MyMethodBeforeAdvice implements MethodBeforeAdvice{
	@Override
	public void before(Method method, Object[] args, Object arg2) throws Throwable {
		System.out.println("前置通知.....目标对象："+method.getName());
		
	}

}

//后置通知
public class MyAfterReturingAdvice implements AfterReturningAdvice {
	@Override
	public void afterReturning(Object returnvalue, Method method,
	 Object[] arg2, Object target) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("后置通知.....目标对象：" + returnvalue);
	}

}

//环绕通知
public class MyMethodInterceport implements MethodInterceptor {
	@Override
	public Object invoke(MethodInvocation invocation) throws Throwable {
		System.out.println("目标对象执行之前...");
		//执行目标对象的方法
		Object obj = invocation.proceed();
		System.out.println("目标对象开始执行...");
		System.out.println("目标对象执行之后...");
		if (obj !=null && obj instanceof String) {
			return obj.toString().toUpperCase();
		}
		return null;
	}
}

//异常通知
public class MyThorwsAdvice implements ThrowsAdvice {
	public void afterThrowing(Exception e) {
		System.out.println("异常通知:" + e.getMessage());
	}
}

XML配置信息

	<!-- 注册目标对象 -->
	<bean class="com.sxt.service.UserServiceImp" id="userService"/>
	
	<!-- 注册前置通知对象 -->
	<bean class="com.sxt.advice.MyMethodBeforeAdvice" id="methodBeforeAdvice"/>
	<!-- 注册后置通知对象 -->
	<bean class="com.sxt.advice.MyAfterReturingAdvice" id="afterReturningAdvice"/>
	<!-- 注册环绕通知对象 -->
	<bean class="com.sxt.advice.MyMethodInterceport" id="methodInterceptor"/>
	<!-- 注册异常通知对象 -->
	<bean class="com.sxt.advice.MyThorwsAdvice" id="myThorwsAdvice"/>
	
	<!-- 获取代理对象 -->
	<bean id="factorybean" class="org.springframework.aop.framework.ProxyFactoryBean">
		<!-- 获取目标对象 -->
		<property name="target" ref="userService"/>
		<!-- 设置目标对象实现的接口 -->
		<property name="interfaces" value="com.sxt.service.UserService"/>
		<!-- 绑定对应的通知 -->
		<property name="interceptorNames">
			<list>
			 	<value>methodBeforeAdvice</value><!-- 前置通知 -->
				<value>afterReturningAdvice</value><!-- 后置通知  -->
				<value>methodInterceptor</value> <!-- 环绕通知 -->
				<value>myThorwsAdvice</value> <!-- 异常通知 -->
			</list>
		</property>
	</bean>

二、基于AspectJ的方式实现AOP

在Spring中使用AOP开发时，我们一般使用AspectJ的方式去实现

1、AOP切入点表达式

在这里插入图片描述
切入点表达式要匹配的对象就是目标方法的方法名。所以，execution表达式中明显就是方法的签名。注意，表达式中加[ ]的部分表示可省略部分，各部分间用空格分开。在其中可以使用以下符号
在这里插入图片描述
execution(public * (. .))
指定切入点为：任意公共方法。
execution( set*(. .))
指定切入点为：任何一个以“set”开始的方法。
execution(* com.xyz.service..(. .))
指定切入点为：定义在service包里的任意类的任意方法。
execution(* com.xyz.service. ..(. .))
指定切入点为：定义在service包或者子包里的任意类的任意方法。“…”出现在类名中时，
后面必须跟“”，表示包、子包下的所有类。
execution( .service..(. .))
指定只有一级包下的serivce子包下所有类(接口)中的所有方法为切入点
execution( . .service..*(. .))
指定所有包下的serivce子包下所有类(接口)中的所有方法为切入点

2、代码实现
开启AOP

在这里插入图片描述
然后导入AspectJ的包
在这里插入图片描述
XML文件代码

	<!-- 注册目标对象 -->
	<bean class="com.sxt.service.UserServiceImp" id="userService"/>
	<bean class="Sxt.aspectJ.MyAdvice"/>
	<aop:aspectj-autoproxy/>

然后创建通知类Advice

@Aspect
public class MyAdvice {
	/*前置通知*/
	@Before(value="execution(* com.sxt.service.*.*(..))") 
	//这个注解表示切入点在com.sxt.service这个包下的所有的方法，也可以选择不切所有的方法。下面的也一样
	public void before() {
		System.out.println("前置通知执行......");
	}
	
	/*后置通知*/
	@AfterReturning(value="execution(* com.sxt.service.*.*(..))",returning="obj")
	public void after(Object obj) {
		System.out.println("后置通知执行，传过来的参数是：" + obj);
	}
	
	/*环绕通知*/
	@Around(value="execution(* com.sxt.service.*.*(..))")
	public Object aroud(ProceedingJoinPoint pjp) {
		System.out.println("环绕通知执行 开始....");
		Object obj = null;
		try {
			obj = pjp.proceed();
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		System.out.println("环绕通知执行 结束....");
		if (obj !=null && obj instanceof String) {
			return "结束";
		}
		return obj;
	}
	
	/*异常通知*/
	@AfterThrowing(value="execution(* com.sxt.service.*.*(..))",throwing="e")
	public void afterThrowing(Exception e) {
		System.out.println("异常通知:" + e.getMessage());
	}

	/*最终通知*/
	//最终通知不管异常与否都会执行
	@After(value="execution(* com.sxt.service.*.*(..))")
	public void after(Exception e) {
		System.out.println("最终通知。。。" );
	}
}

运行

public class TestAspectJ {
	public static void main(String[] args) {
	ApplicationContext ac=new ClassPathXmlApplicationContext("ApplicationContextAspectJ.xml");
		UserService bean =ac.getBean(UserService.class);
		bean.helloword("word");
		System.out.println("*----------------*");
		bean.hellojava("java");
	}
}

AspectJ也可以是配置文件的方式，这里就写个前置的方式作为例子

<!-- 注册目标对象 -->
	<bean class="com.sxt.service.UserServiceImp" id="userService"/>
	<bean class="com.sxt.advice.MyAdvice" id="MyAdvice"/>
	
<!-- AOP配置 -->
	<aop:config>
		<aop:aspecr ref="MyAdvice"/>
		<aop:pointcut expression="execution(* com.sxt.service.*.*(..))" id="mypointcut"/>
		<!-- 前置通知 -->
		<aop:before method="before" pointcut-ref="myPointcut"/>
		</aop:aspecr >
	</aop:config>

三、JDBCTemplate的使用

导入包
在这里插入图片描述
然后根据数据库创建一个对应的对象类User

代码实现：

@Repository
public class UserDao {
	/**
	 * 在XML文件中注册，然后在使用
	 */
	@Autowired  //此注解意味去容器中寻找JdbcTemplate 
	private JdbcTemplate jabcTemplata;
	private String sql;
	
	public void addUser() {//添加
		sql="insert into t_user(name,pwd,role) values(?,?,?);";
		int update = jabcTemplata.update(sql, "joker","1233","2");
		System.out.println(update);
	}
	public void updateUser() {//修改
		sql="update t_user set name=?,pwd=?,role=? where id=?";
		int update = jabcTemplata.update(sql, "jfl","11111","1",10);
		System.out.println(update);
	}
	public void deleteUser() {//删除
		sql="delete from t_user where id=?";
		int update = jabcTemplata.update(sql, 10);
		System.out.println(update);
	}
	public void queryUser() {//查找
		sql="select * from t_user";
		//jabcTemplata.query(String sql,RowMapper<T> rowMapper) 这里返回的是数组，需要用到这个方法
		List<User> list = jabcTemplata.query(sql, new BeanPropertyRowMapper<User>(User.class));
		for (User user : list) {
			System.out.println(user);
		}
	}
}

XML配置信息

<!-- 开启扫描 -->
	<context:component-scan base-package="Sxt.Template"/>
	
	<!-- 配置DateSource -->
	<!-- DriverManagerDataSource 这个是Spring包下的 -->
	<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource">
		<property name="url" value="地址值"/>
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="username" value="账号"/>
		<property name="password" value="密码"/>
	</bean>
	
	<!-- 配置JDBCTemplate -->
	<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
		<property name="dataSource" ref="dataSource"/>
	</bean>

四、事务处理

事务是指单个逻辑工作单元执行的一系列操作，他们要么全部成功，要么全部失败。
一个逻辑性工作单元如果是事务单元，那他必须要满足所谓的ACID（原子性、一致性、隔离性、持久性）属性。

话不多说上案例
这里就拿JDBC操作当做案例吧

public class UserDao {
	public void addUser() throws SQLException {
		PreparedStatement ps1 = null;
		PreparedStatement ps2 = null;
		Connection conn =null;	
		try {
			Class.forName(driverName);
			conn = DriverManager.getConnection(url, user, password);
			//关闭自动提交
			conn.setAutoCommit(false);
			//第一个数据库操作
			String sql="insert into t_user(name,pwd,role) values(?,?,?);";
			ps1=conn.prepareStatement(sql);
			ps1.setString(1, "jacklove");
			ps1.setString(2, "123456");
			ps1.setString(3, "2");
			int upd = ps1.executeUpdate();
			//第二个数据库操作
			sql="update t_user set name=?,pwd=?,role=? where id=?";
			ps2=conn.prepareStatement(sql);
			ps2.setString(1, "aaa");
			ps2.setString(2, "123456");
			ps2.setString(3, "10");
			ps2.executeUpdate();
			//手动提交
			conn.commit();
			System.out.println(upd);
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			conn.rollback();
		}finally {
			conn.close();
			ps1.close();
			ps2.close();
		}
	}
	public static void main(String[] args) {
		UserDao dao=new UserDao();
		try {
			dao.addUser();
		} catch (SQLException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

这里有两个SQL语句，假如没有使用事务操作，那么如果其中有一条语句错误，另一条也可能会执行，这样就容易导致数据的不完整，所以这里使用事务，要么同时成功增加和修改，要么都失败。
上述代码可以利用动态代理简化。

五、拓展：ACID具体

原子性（Atomicity）

指整个数据库事务是不可分割的工作单位。只有使据库中所有的操作执行成功，才算整个事务成功；事务中任何一个SQL语句执行失败，那么已经执行成功的SQL语句也必须撤销，数据库状态应该退回到执行事务前的状态。

一致性（Consistency）

指数据库事务不能破坏关系数据的完整性以及业务逻辑上的一致性。例如对银行转帐事务，不管事务成功还是失败，应该保证事务结束后ACCOUNTS表中Tom和Jack的存款总额为2000元。

隔离性（Isolation）

指的是在并发环境中，当不同的事务同时操纵相同的数据时，每个事务都有各自的完整数据空间。

持久性（Durability）

指的是只要事务成功结束，它对数据库所做的更新就必须永久保存下来。即使发生系统崩溃，重新启动数据库系统后，数据库还能恢复到事务成功结束时的状态。

之也
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值