Spring(二)之IOC的注解及AOP开发（XML）

最新推荐文章于 2024-03-24 00:45:56 发布

欢乐·猿

最新推荐文章于 2024-03-24 00:45:56 发布

阅读量86

点赞数

本文链接：https://blog.csdn.net/weixin_42278316/article/details/103017711

版权

Spring的IOC的注解开发

Spring 的的 Bean 管理:( 注解方式)
步骤一: 下载 Spring 的开发包:
官网：http://spring.io/
下载地址：
http://repo.springsource.org/libs-release-local/org/springframework/spring
解压:(Spring 目录结构:)

docs :API 和开发规范.
libs :jar 包和源码.
schema :约束.
步骤二: 创建 web 项目, 引入 Spring 的开发包:

在 Spring 的注解的 AOP 中需要引入 spring-aop 的 jar 包。
步骤三: 引入相关配置文件:
在spring-framework-4.2.4.RELEASE\docs\spring-framework-reference\html\xsd-configur
ation.html中引入 context 的约束:

步骤四: 编写相关的类:

package com.wangshi.spring.demo;

public interface UserDao {
	
	public void save();

}

package com.wangshi.spring.demo;

import org.springframework.stereotype.Component;

/**
 * @author wanghaichaun
 */
public class UserDaoImpl implements UserDao{

	@Override
	public void save() {
		System.out.println("执行UserDaoImpl中的保存方法......");
		
	}
}

步骤五: 配置注解扫描:

<!--使用IOC的注解开发,配置属性扫描(哪些包下的类使用IOC的注解)-->
<context:component-scan base-package="com.wangshi.spring.demo.SpringDemo01"/>

在相关的类上添加注解:

package com.wangshi.spring.demo;

import org.springframework.stereotype.Component;

/**
 * @author wanghaichaun
 *使用springIOC的注解方式
 */
@Component(value="UserDao")//相当于<bean id="userDao" class="com.wangshi.spring.demo.UserDaoImpl"/>
public class UserDaoImpl implements UserDao{

	@Override
	public void save() {
		System.out.println("执行UserDaoImpl中的保存方法......");
		
	}

}

编写测试类:
注意要加spring-aop-4.2.4.RELEASE.jar

@Test
	//spring用注解的方式来做
	public void demo02(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	}

Spring 的 Bean 管理的中常用的注解:

1.@Component: 组件( 作用在类上)

Spring 中提供@Component 的三个衍生注解:(功能目前来讲是一致的)

@Controller :WEB 层
@Service : 业务层
@Repository : 持久层
这三个注解是为了让标注类本身的用途清晰，Spring 在后续版本会对其增强;

2.属性注入的注解:( 使用注解注入的方式, 可以不用提供 set 方法)

@Value :用于注入普通类型.

package com.wangshi.spring.demo;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**Dao层的实现
 * @author wanghaichaun
 *使用springIOC的注解方式
 */
@Component(value="userDao")//相当于<bean id="userDao" class="com.wangshi.spring.demo.UserDaoImpl"/>
public class UserDaoImpl implements UserDao{
	//没有set方法的时候
	@Value(value="啦啦3")
	private String name;
	
/*	//有set方法
	@Value(value="啦啦")
	public void setName(String name) {
		this.name = name;
	}*/

	@Override
	public void save() {
		System.out.println("执行UserDaoImpl中的保存方法......"+name);
	}
}

@Autowired :自动装配:

默认按类型进行装配.
按名称注入:
- @Qualifier:强制使用名称注入.

@Resource 相当于:

@Autowired 和@Qualifier 一起使用.

3.Bean 的作用范围的注解:

@Scope:

singleton: 单例
prototype: 多例

4.Bean 的生命周期的配置:

@PostConstruct :相当于 init-method
@PreDestroy :相当于 destroy-method

5.Spring 的 Bean 管理的方式的比较:

在这里插入图片描述
XML 和注解:

XML :结构清晰.
注解 :开发方便.(属性注入.)
实际开发中还有一种 XML 和注解整合开发:
* Bean 有 XML 配置. 但是使用的属性使用注解注入.

	<!-- 使用springIOC的注解来实现======= -->
	<!--使用IOC的注解开发,配置属性扫描(哪些包下的类使用IOC的注解)-->
	<!-- 扫描是为了扫描类上的注解 -->
	<context:component-scan base-package="com.wangshi.spring"/>
	
	<!--在没有扫描的情况下，使用属性注入的注解：@Resource  @value  @Autowired @Qualifier-->
	<context:annotation-config />



package com.wangshi.spring.demo03;

import javax.annotation.Resource;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

/**
 * @author wanghaichan
 *xml和注解的开发
 */
@Component("productService1")
public class ProductService {
	
	@Resource(name="productDao")
	private ProductDao productDao;
	
	@Resource(name="orderDao")
	private OrderDao  orderDao;
	
/*	//使用xml的方式*/
	/*public void setProductDao(ProductDao productDao) {
		this.productDao = productDao;
	}

	public void setOrderDao(OrderDao orderDao) {
		this.orderDao = orderDao;
	}*/


	public void save() {
		System.out.println("这是ProdectDemo的保存。。。。。");
		productDao.save();
		orderDao.save();
	}
}

AOP 的概述

1.什么是 AOP?
Spring 是解决实际开发中的一些问题:

AOP 面向切面编程,是为了解决 OOP 中遇到的一些问题.是 OOP 的延续和扩展.

2.为什么学习 AOP?
对程序进行增强:不修改源码的情况下.

AOP 可以进行权限校验,日志记录,性能监控,事务控制.

3.Spring 的的 AOP 的由来:
AOP 最早由 AOP 联盟的组织提出的,制定了一套规范.Spring 将 AOP 思想引入到框架中,必须遵守 AOP 联盟的规范.

Spring的AOP有自己的实现方式,不过非常繁琐,AspectJ是一个AOP框架,Spring引入AspectJ作为自身AOP的开发.
Spring两套AOP开发的方式:
	* Spring传统方式(弃用)
	* Spring基于AspectJ的AOP的开发(使用)

4 .底层实现:
代理机制:

Spring 的 AOP 的底层用到两种代理机制：
- JDK 的动态代理 :针对实现了接口的类产生代理.
- Cglib 的动态代理 :针对没有实现接口的类产生代理. 应用的是底层的字节码增强的技术生成当前类的子类对象.

5.Spring 底层 AOP 的实现原理: （了解）
JDK 动态代理增强一个类中方法:

package com.wangshi.spring_aop.Demo;

import org.junit.Test;

public class SpringAopDemo {
	
	
	@Test
	public void demo01(){
	UserDao userDao = new UserDaoImpl();
	//创建代理
	UserDao jdkproxy = new jdkProxy(userDao).createProxy();
	jdkproxy.save();
	jdkproxy.delete();
	jdkproxy.update();
	jdkproxy.find();
	}

}


package com.wangshi.spring_aop.Demo;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


/**
 * @author wanghaihcaun
 *这是jdk的动态代理对UserDao产生的代理
 */

public class jdkProxy implements InvocationHandler{
	
	//将被增强的对象传入到代理中
	private UserDao userDao;
	
	public jdkProxy(UserDao userDao) {
		this.userDao = userDao;
	}

	/**
	 * 产生UserDao代理的方法
	 */
	public UserDao createProxy(){
		
		UserDao userDaoProxy = (UserDao)Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
				userDao.getClass().getInterfaces(), this);
		return userDaoProxy;
		
	}
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		if("save".equals(method.getName())){
			//在 save之前 增强:
			System.out.println("权限校验===========");
			return method.invoke(userDao, args);
		}
		return method.invoke(userDao, args);
	}

}

Cglib 动态代理增强一个类中的方法:

package com.wangshi.spring_aop.Demo;

import java.lang.reflect.Method;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

/**
 * @author wanghaichuan
 *Cglib动态代理
 */
public class MyCglibProxy implements MethodInterceptor{

	private CustomerDao customerDao;
	
	//构造
	public MyCglibProxy(CustomerDao customerDao) {
		this.customerDao = customerDao;
	}


	//生成cglib产生代理的方法
	 CustomerDao createProxy(){
		
		//1.创建一个cglib的核心类
		Enhancer enhance =  new Enhancer();
		//2.设置父类
		enhance.setSuperclass(CustomerDao.class);
		//3.设置回调(类似于InvocationHandler对象)
		enhance.setCallback(this);
		//4.生成代理
		CustomerDao customerDemoProxy = (CustomerDao) enhance.create();
		
		return customerDemoProxy;
		
	}
	
	@Override
	public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
		if("delete".equals(method.getName())){
			//Object obj = methodProxy.invoke(proxy, args);
			System.out.println("日志记录====================");
			return methodProxy.invokeSuper(proxy, args);
		}
		return methodProxy.invokeSuper(proxy, args);
	}

}

	@Test
	//这是cglib的动态代理方式
	public void demo02(){
		CustomerDao custDao = new CustomerDao();
		//创建代理
		CustomerDao myCglibProxy = new MyCglibProxy(custDao).createProxy();
		myCglibProxy.save();
		myCglibProxy.find();
		myCglibProxy.update();
		myCglibProxy.delete();
	}

6.Spring 的基于 AspectJ 的的 AOP 开发

AOP 的开发中的相关术语:

Joinpoint(连接点)  :所谓连接点是指那些被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只
				 	支持方法类型的连接点.
Pointcut(切入点)	  :所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义.
Advice(通知/增强)   :所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知.通知分为前置通知,后置
				 通知,异常通知,最终通知,环绕通知(切面要完成的功能)
Introduction(引介)  :引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类
				  动态地添加一些方法或 Field.
Target(目标对象)  :代理的目标对象
Weaving(织入)  :是指把增强应用到目标对象来创建新的代理对象的过程.
spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装在期织入
Proxy（代理） :一个类被 AOP 织入增强后，就产生一个结果代理类
Aspect(切面)  : 是切入点和通知（引介）的结合

在这里插入图片描述
7.Spring 使用 AspectJ 进行 AOP 的开发：XML 的方式（***** ）
引入相应的 jar

	* spring 的传统 AOP 的开发的包
	  spring-aop-4.2.4.RELEASE.jar
	  com.springsource.org.aopalliance-1.0.0.jar
	* aspectJ 的开发包:
   	  com.springsource.org.aspectj.weaver-1.6.8.RELEASE.jar
	  spring-aspects-4.2.4.RELEASE.jar

在这里插入图片描述
引入 Spring 的配置文件

引入 AOP 约束:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

编写目标类

创建接口和类:
public interface OrderDao {
public void save();
public void update();
public void delete();
public void find();
}
public class OrderDaoImpl implements OrderDao {

}

目标类的配置:

	<!-- 目标类Order -->
	<bean id="orderDao" class="com.wangshi.spring.demo.OrderDaoImpl">
	</bean>

整合 Junit 单元测试

package com.wangshi.spring.demo;

import javax.annotation.Resource;

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

/**
 * @author wanghaichuan
 *单元测试  spring和aspectJ的测试xml
 */
//注解方式
//引入测试test包,进行单元测试
@RunWith(SpringJUnit4ClassRunner.class)
//加载配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo {
	
	@Resource(name="orderDao")
	private OrderDao orderDao;
	
	@Test
	//传统写法
	public void demo(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		OrderDao orderDao = (OrderDao) applicationContext.getBean("orderDao");
		orderDao.save();
		orderDao.update();
		orderDao.find();
		orderDao.delete();
		
	}
	
	@Test
	//注解写法
	public void demo01(){
		orderDao.save();
		orderDao.update();
		orderDao.find();
		orderDao.delete();
	}

}

通知类型:

前置通知 ：在目标方法执行之前执行.   获得切入点

后置通知 ：在目标方法执行之后执行  获得方法的返回值

环绕通知 ：在目标方法执行前和执行后执行    可以阻止目标方法的执行

异常抛出通知：在目标方法执行出现异常的时候执行     可以获得异常,无异常不显示

最终通知 ：无论目标方法是否出现异常最终通知都会执行.

引介通知...

package com.wangshi.spring.demo;

import javax.annotation.Resource;

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

/**
 * @author wanghaichuan
 *单元测试  spring和aspectJ的测试xml
 */
//注解方式
//引入测试test包,进行单元测试
@RunWith(SpringJUnit4ClassRunner.class)
//加载配置文件
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo {
	
	@Resource(name="orderDao")
	private OrderDao orderDao;
	
	@Test
	//传统写法
	public void demo(){
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		OrderDao orderDao = (OrderDao) applicationContext.getBean("orderDao");
		orderDao.save();
		orderDao.update();
		orderDao.find();
		orderDao.delete();
	}
	
	@Test
	//注解写法
	public void demo01(){
		orderDao.save();
		orderDao.update();
		orderDao.find();
		orderDao.delete();
	}

}

<?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">
	
	<!-- 目标类Order 配置被增强的对象-->
	<bean id="orderDao" class="com.wangshi.spring.demo.OrderDaoImpl"/>
	<!--将切面类交给Spring管理-->
	<bean id="myAspect" class="com.wangshi.spring.demo.MyAspectJXML"/>
	
	
	<!-- 通过AOP的配置完成对目标类产生代理 -->
	<aop:config>
		<!-- 表达式配置哪些类的哪些方法需要进行增强 -->
		<aop:pointcut expression="execution(* com.wangshi.spring.demo.OrderDaoImpl.save(..))" id="pointcut1"/>
		<aop:pointcut expression="execution(* com.wangshi.spring.demo.OrderDaoImpl.delete(..))"  id="pointcut2"/>
		<aop:pointcut expression="execution(* com.wangshi.spring.demo.OrderDaoImpl.update(..))"  id="pointcut3"/>
		<aop:pointcut expression="execution(* com.wangshi.spring.demo.OrderDaoImpl.find(..))"  id="pointcut4"/>
		
		<!--配置切面 -->
		<aop:aspect ref="myAspect">
			<!--前置通知=================  -->
			<aop:before method="checkPri" pointcut-ref="pointcut1"/>
			<!--环绕通知=================  -->
			<aop:around method="around" pointcut-ref="pointcut3"/>
			<!--后置通知=================  -->
			<aop:after-returning method="writeLog" pointcut-ref="pointcut2" returning="result"/>
			
			<!--异常抛出通知=================  -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"/>
			<!--最终通知=================  -->
			<aop:after method="after" pointcut-ref="pointcut4"/>
		</aop:aspect>
	</aop:config>
	
</beans>

package com.wangshi.spring.demo;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.stereotype.Component;

/**切面类
 * @author wanghaichaun
 */

@Component("myAspect")
public class MyAspectJXML {
	/**
	 *前置通知
	 *@param joinPoint
	 */
	public void checkPri(JoinPoint joinpoint){
		System.out.println("权限校验======="+joinpoint);
	}
	/**
	 * 后置通知
	 *
	 */
	public void writeLog(Object result){
		System.out.println("日志记录======="+result);
	}
	
	/**
	 * 环绕通知 ,性能监控
	 *@throws Throwable
	 */
	private Object around(ProceedingJoinPoint joinPoint) throws Throwable{
		System.out.println("环绕前通知========");
		Object obj = joinPoint.proceed();
		System.out.println("环绕后通知========");
		return obj;
	}
	
	/**
	 * 异常抛出通知
	 */
	public void afterThrowing(Throwable ex){//无异常不变,加个异常
		System.out.println("异常抛出通知=========="+ex);
		
	}
	
	/**
	 *最终通知:相当于finally
	 */
	public void after(){
		System.out.println("最终通知=============");
	}
}

切入点表达式:

	execution(表达式)
	表达式:
	[方法访问修饰符] 方法返回值 包名.类名.方法名(方法的参数)
	public * com.wangshi.spring.dao.*.*(..)
	* com.wangshi.spring.dao.*.*(..)
	* com.wangshi.spring.dao.UserDao+.*(..)
	* com.wangshi.spring.dao..*.*(..)

欢乐·猿

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring(二)之IOC的注解及AOP开发（XML）

Spring的IOC的注解开发Spring 的的 Bean 管理:( 注解方式)步骤一: 下载 Spring 的开发包:官网：http://spring.io/下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring 解压:(Spring 目录结构:)docs :A...
复制链接

扫一扫