Spring IOC 和 AOP的扩展(注解使用详解: )

ゝ一世哀愁。 2022-12-03 09:15 254阅读 0赞

# 多种方式实现依赖注入： #

**[上一章][Link 1]简单的使用Spring 通过 setter 访问器实现对属性的赋值; 称为 `"设值注入"`**  
**Spring 还提供了通过构造方法赋值的能力: `"构造注入"`**  
上代码！  
Data接口类型：**`Data.java`**

//数据库接口
    public interface Data { 
    	//描述
    	public void show();
    }

两个实现接口的类：  
**`MysqlData.java 和 OracleData.java`**

//Mysql数据库
    public class MysqlData implements Data { 
    	@Override
    	public void show() { 
    		// TODO Auto-generated method stub
    		System.err.println("Mysql数据库");
    	}
    }
    
    
    
    //Mysql数据库
    public class MysqlData implements Data { 
    	@Override
    	public void show() { 
    		// TODO Auto-generated method stub
    		System.err.println("Mysql数据库");
    	}
    }

实体类：**`User.Java`**

//上一篇文章简单的使用Spring 通过 setter 访问器实现对属性的赋值; 称为 "设值注入"
    //Spring 还提供了通过构造方法赋值的能力: "构造注入"
    //用户类
    public class User { 
    	//无参构造函数;
    	public User(){  
    		//设置注入时,Spring通过无参构造方法创建实例对象; 调用set()赋值
    		//为了确保灵活性,建议自行添加一个无参构造方法,防止异常;
    	};
    	//带参构造函数
    	public User(Data data,String can){ 
    		this.date = data;
    		System.out.println(can);  //打印参数,
    	}
    	//初始化方法()
    	public void into(){ 
    		this.date.show();
    	// System.out.println(1/0); //主动抛出异常
    	}
    	
    	//数据库接口,类型对象;
    	private Data date;
    	
    	//get/set 方法;
    	public Data getDate() { 
    		return date;
    	}
    	public void setDate(Data date) { 
    		this.date = date;
    	}
    }

Spring 配置文件: **`applicationContext.xml`**

<bean id="user" class="com.wsm.entity.User" p:date-ref="oracle" />

**构造注入 与 设值注入的区别：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center]  
注意：配置文件是 xml 所以如果注入一些特殊字符还需要进行一些处理…

…  
**Spring注入不同数据类型: list map set prop**  
**`CS.java`**

import java.util.List;
    import java.util.Map;
    import java.util.Properties;
    import java.util.Set;
    
    public class CS { 
    	private List<String> list;			//泛型 String
    	private Map<String, Object> map;	//泛型 String Object
    	private Set<Integer> set;			//泛型 integer
    	private Properties prop;			//跟Map 键值对存储类似,不同是它是 name-value name只能是字符串类型;
    	
    	//重写toString(); 用于待会打印查看结果...
    	@Override
    	public String toString() { 
    		return "CS [list=" + list + ", map=" + map + ", set=" + set + ", prop="
    				+ prop + "]";
    	}
    	
    	//get/set方法
    	public List<String> getList() { 
    		return list;
    	}
    	public void setList(List<String> list) { 
    		this.list = list;
    	}
    	public Map<String, Object> getMap() { 
    		return map;
    	}
    	public void setMap(Map<String, Object> map) { 
    		this.map = map;
    	}
    	public Set<Integer> getSet() { 
    		return set;
    	}
    	public void setSet(Set<Integer> set) { 
    		this.set = set;
    	}
    	public Properties getProp() { 
    		return prop;
    	}
    	public void setProp(Properties prop) { 
    		this.prop = prop;
    	}
    }

Spring 配置文件: **`applicationContext.xml`**

<bean id="cs" class="com.wsm.entity.CS" >
    		
    		<property name="list">
    			<list>
    				<value>root</value>
    				<value>system</value>
    			</list>
    		</property>
    		<property name="set">
    			<set>
    				<value>100</value>
    				<value>200</value>
    			</set>
    		</property>
    		<property name="map">
    			<map>
    				<entry key="one" value="打篮球"></entry>
    				<entry key="two" value="踢足球"></entry>
    			</map>
    		</property>
    		<property name="prop">
    			<props>
    				<prop key="张">三丰</prop>
    				<prop key="王">无极</prop>
    			</props>
    		</property>
    	</bean>

// 对于Spring的注入大致就是这么多… 现在是不是对IOC 又有更多了解了呢… 下面介绍一下 AOP;

# Spring的 AOP 扩展： #

[上一章][Link 1]介绍了, Spring的Aop; 前置增强 后置增强  
现在让我们来更加深入了解AOP：

> 将复杂的需求分解出不同方面，将散布在系统中的公共功能集中解决  
> 采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能  
> 对于这些增强的方法代码,把它们集中放在一个增强类中, 方便处理:

增强处理类：**`Aop.java`**

import java.util.Arrays;
    import org.apache.log4j.Logger;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    //增强处理类：
    public class Aop { 
    	//创建日志对象;
    	private Logger log = Logger.getLogger(Aop.class);
    	//可拔插的处理方案,增强方法都是 可拔插式的,用就在配置文件中定义,不用就直接删除即可;
    	
    	//前置增强 //连接点对象
    	public void beforeee(JoinPoint joinPoint){ 
    		log.info("前置,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()));
    	}
    	
    	//后置增强 //连接点对象,返回值
    	public void afterReting(JoinPoint joinPoint,Object result){   
    		log.info("后置,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()) + ",方法的返回值是：" + result);
    	}
    	
    	
    	//异常抛出增强 特点：
    		//在目标方法抛出异常时织入增强处理; 相当于 try-catch, catch中的代码,连接点方法出现异常会执行该 异常抛出增强中的方法();
    	public void afterThrowing(JoinPoint joinPoint, RuntimeException e) {  
    		//参数 RuntimeException 表示运行期异常,可有多个根据,不同异常参数进行判断,处理不同异常的解决;
    		System.out.println("程序运行异常,方法结束");
    		System.out.println("是否是算术异常"+(e instanceof ArithmeticException));   //判断异常类型;
    		log.info("异常增强 ,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + "出现的异常是：" + e);
    	}
    	
    	//最终增强特点：
    		//无论方法是否抛出异常，都会在目标方法最后织入增强处理，即：该增强都会得到执行,类似于 finally一般用于释放资源;
    		//可以为各功能模块提供统一的，可拔插的处理方案;
    	public void after(JoinPoint joinPoint) { 
    		log.info("最终增强,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()));
    	}
    
    	//环绕增强 特点：
    		//目标方法前后都可织入增强处理,功能最强大的增强处理. 相当于：前置增强 后置增强 异常抛出增强 最终增强 的合集; 所以我就可以把上面的注释了!
    		//可获取或修改目标方法的参数、返回值，可对它进行异常处理，甚至可以决定目标方法是否执行. 
    	public Object around(ProceedingJoinPoint joinPoint) { 
    		Object result = null;
    		try { 
    			//前置增强
    			log.info("前置,调用" + joinPoint.getTarget() + "类,下的方法是"
    					+ joinPoint.getSignature().getName() + ",方法的参数是:"
    					+ Arrays.toString(joinPoint.getArgs()));
    			//后置增强
    			log.info("后置,调用" + joinPoint.getTarget() + "类,下的方法是"
    					+ joinPoint.getSignature().getName() + ",方法的参数是:"
    					+ Arrays.toString(joinPoint.getArgs()) + ",方法的返回值是：" + result);
    			
    			result = joinPoint.proceed(); //获取连接点返回值参数; 
    		} catch (ArithmeticException e) {  //算术异常
    			//异常抛出增强
    			System.err.println("算术异常");
    		} catch (Throwable e){  //异常父类
    			System.err.println("异常");
    		} 
    		finally{ 
    			//最终增强
    			log.info("最终增强,调用" + joinPoint.getTarget() + "类,下的方法是"
    					+ joinPoint.getSignature().getName() + ",方法的参数是:"
    					+ Arrays.toString(joinPoint.getArgs()));
    		}
    		return result;
    	}
    }

Spring 配置文件: **`applicationContext.xml`**  
使用AOP前注意： Aop命名空间;

<aop:config>
    		
    		<aop:pointcut expression="execution (public void into())" id="mypoint"/>
    		
    		<aop:aspect ref="myLogAop">  
    		
    			
    			
    			<aop:around method="around" pointcut-ref="mypoint"/>
    		</aop:aspect>
    	
    	</aop:config>
    	
    	
    	<bean id="myLogAop" class="com.wsm.aop.Aop"></bean>

--------------------

**最后最后,奉上Run 开始运行啦**  
`Run.Java`

import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import com.wsm.entity.CS;
    import com.wsm.entity.User;
    
    public class Run { 
    	public static void main(String[] args) { 
    		通过 ClassPathXmlApplicationContext 实例化 Spring 上下文;
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//创建user实例
    		User u = (User)context.getBean("user");
    		//调用方法
    		System.out.println("------------into()-------------");
    		u.into();
    		System.out.println();
    		//创建cs实例
    		CS cs = (CS)context.getBean("cs");
    		System.out.println("--------list--map--set------prop--------------");
    		System.out.println(cs); 	//打印实例,重写了toString();...
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 2]  
项目结构是随意写的,别建议…后面会注意的;

\*\*感谢观看,有疑问的欢迎提出,一起进步. 可以看我之前的文章解答疑问：[click 猛击！ ][Link 1]

# Spring使用注解完成IOC / AOP: #

## **使用注解实现 IOC 配置：** ##

根据上面实例代码进行更改：  
**Data接口类型：`Data.java`** 没啥变化;

//数据库接口
    public interface Data { 
    	//描述
    	public void show();
    	
    }

两个实现接口的类：  
**`MysqlData.java 和 OracleData.java`**

import org.springframework.stereotype.Repository;
    //Mysql数据库
    @Repository("mysql")    //相当于 <bean id="mysql" class="com.wsm.dao.MysqlData" ></bean> 括号里面就是ID;
    public class MysqlData implements Data { 
    	@Override
    	public void show() { 
    		// TODO Auto-generated method stub
    		System.err.println("Mysql数据库");
    	}
    }

import org.springframework.stereotype.Repository;
    //Oracle数据库
    @Repository("Oracle")  
    public class OracleData implements Data { 
    	@Override
    	public void show() { 
    		// TODO Auto-generated method stub
    		System.err.println("Oracle数据库");
    	}
    }

> Spring 注解实现IOC：  
> 注解方式将Bean的定义信息和Bean实现类结合在一起，Spring提供的注解有  
> @Component：  
> \------@Component(“xx”) 相当于在 Spring配置中编写 ：< bean id=“xx” class=“当前类的引用” > </ bean> 实现Bean组件的定义 。  
> \*\*除了 @Component 还有以下几种… : \*\*  
> @Repository ：用于标注DAO类  
> @Service ： ：用于标注业务类  
> @Controller ：用于标注控制器类  
> \------使用特定的Spring 注解, 使组件用途更加清晰, 有可能在以后Spring 会给它们添加特殊的功能,所以建议规范来使用… (如果Spring真的更改了特殊用法麻烦评论告知~^^)

## **使用注解实现Bean 组件装配：** ##

import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Repository;
    @Repository("user")
    public class User { 
    	
    	//Spring 注解完成组件装配：
    //方式一：
    // @Autowired //自动实例化：@Autowired对属性完成注入依赖对象,之前对其赋值,此时可以省略 setter();
    	/*对于@Autowired：@Autowired(required = false/true) * @Autowired注解进行匹配时候,如果找不到相匹配的Bean组件,Spring容器会抛出异常; * 此时如果 依赖不是必须的,为了避免抛出异常可以设置 required = false * required默认为 true ：必须找到匹配的Bean完成装配,否则抛出异常; * */
    // private Data date; 
    
    //方式二：
    	@Autowired			//@Autowired注解实现Bean的自动装配，默认按类型匹配。
    	@Qualifier("mysql") //也可以使用@Qualifier指定Bean的名称
    	private Data date;
    //方式三：
    	//带参构造函数: 也可以对方法的入参进行标注
    	public User(@Qualifier("mysql")Data data){ 
    		this.date = data;
    	}
    	
    	//无参构造
    	public User(){ }
    
    	//初始化
    	public void into(){ 
    		this.date.show();
    // System.out.println(1/0); //主动抛出异常
    	}
    	
    	//get/set 方法;
    	public Data getDate() { 
    		return date;
    	}
    	public void setDate(Data date) { 
    		this.date = date;
    	}
    }

补充：(因为实例不是很好描述,如果改实例项目代码. 也感觉不太好就截图了…)  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 3]

字太丑了就没写, 黑笔抹去了 –  
**总结：** 就是 @Resource 可以是,对 @Autowired @Qualifier(“xx”); 的一个整个,可以同时表示两个用法;

--------------------

**Spring 配置文件: `applicationContext.xml`**  
使用注解最大好处就是,大大简化了 Spring配置信息中的代码：只需要一个进行扫描 注解的即可,剩下就是底层的代码…实现;

<context:component-scan base-package="*"></context:component-scan>

## **使用注解完成AOP** ##

import java.util.Arrays;
    
    import org.apache.log4j.Logger;
    import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.After;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.AfterThrowing;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    
    /* * 使用注解定义切面 AspectJ 面向切面的框架，它扩展了Java语言，定义了AOP 语法，能够在编译期提供代码的织入 @AspectJ AspectJ 5新增的功能，使用JDK 5.0 注解技术和正规的AspectJ切点表达式语言描述切面 Spring通过集成AspectJ实现了以注解的方式定义增强类，大大减少了配置文件中的工作量 利用轻量级的字节码处理框架asm处理@AspectJ中所描述的方法参数名 使用@AspectJ，首先要保证所用的JDK 是5.0或以上版本 * */
    
    @Aspect 
    public class Aop { 
    	private Logger log = Logger.getLogger(Aop.class);
    	
    	@Pointcut("execution(public void into())")   //切入点表达式：使用@Pointcut注解表示;
    	public void wsm(){ }							 //切入点签名通过一个普通方法,返回值必须是 void类型;
    												 //引用匹配之后,Myelicpse方法旁边会有小箭头标志~
    	//前置增强 
    	//@Before("wsm()") //使用时直接："方法名()" 即可; 
    	//@Before("execution(public void into())") //与上面效果一样;
    	public void beforeee(JoinPoint joinPoint){ 
    		log.info("前置,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()));
    	}
    	
    	//后置增强
    	//@AfterReturning(pointcut="execution(public void into())",returning="result") //returning="返回值的参数名"
    	public void afterReting(JoinPoint joinPoint,Object result){   
    		log.info("后置,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()) + ",方法的返回值是：" + result);
    	}
    	
    	//异常抛出增强
    	//@AfterThrowing(pointcut="execution(public void into())",throwing="e")
    	public void afterThrowing(JoinPoint joinPoint, RuntimeException e) {  
    		//参数 RuntimeException 表示运行期异常,可有多个根据,不同异常参数进行判断,处理不同异常的解决;
    		System.out.println("程序运行异常,方法结束");
    		System.out.println("是否是算术异常"+(e instanceof ArithmeticException));
    		log.info("异常增强 ,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + "出现的异常是：" + e);
    	}
    	
    	//最终增强
    	//@After("wsm()")
    	public void after(JoinPoint joinPoint) { 
    		log.info("最终增强,调用" + joinPoint.getTarget() + "类,下的方法是"
    				+ joinPoint.getSignature().getName() + ",方法的参数是:"
    				+ Arrays.toString(joinPoint.getArgs()));
    	}
    	
    	//环绕增强
    	@Around("wsm()")
    	public Object around(ProceedingJoinPoint joinPoint) { 
    		Object result = null;
    		try { 
    			//前置增强
    			log.info("前置,调用" + joinPoint.getTarget() + "类,下的方法是"
    					+ joinPoint.getSignature().getName() + ",方法的参数是:"
    					+ Arrays.toString(joinPoint.getArgs()));
    			//后置增强
    			log.info("后置,调用" + joinPoint.getTarget() + "类,下的方法是"
    					+ joinPoint.getSignature().getName() + ",方法的参数是:"
    					+ Arrays.toString(joinPoint.getArgs()) + ",方法的返回值是：" + result);
    			
    			result = joinPoint.proceed(); //获取连接点返回值参数; 
    		
    		} catch (ArithmeticException e) {  //算术异常
    			//异常抛出增强
    			System.err.println("算术异常");
    		} catch (Throwable e){  			  //异常父类：最后处理...
    			System.err.println("父级异常");
    		}
    		finally{ 
    			//最终增强
    			log.info("最终增强,调用" + joinPoint.getTarget() + "类,下的方法是"
    					+ joinPoint.getSignature().getName() + ",方法的参数是:"
    					+ Arrays.toString(joinPoint.getArgs()));
    		}
    		return result;
    		
    	}
    }

**Spring 配置文件: `applicationContext.xml`**

<bean id="myLogAop" class="com.wsm.aop.Aop"></bean> 
    	
    	<aop:aspectj-autoproxy />

`Run.Java`

import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import com.wsm.entity.User;
    //使用注解完成Bean
    public class Run { 
    	public static void main(String[] args) { 
    		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    		//创建user实例
    		User u = (User)context.getBean("user");
    		//调用方法
    		u.into();
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 4]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 5]  
感谢观看

[Link 1]: https://blog.csdn.net/qq_45542380/article/details/108298334
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/1166c0dd22b846e599bbfb4e45f9b551.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/1473b83fdc9941d09172b8011e16ad2b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/951eb59a3d414f0685e53ab1ec19a288.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/115858804ebf418dac7322ea9f4688dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/30391319013841da83c7cea94b89b135.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1NTQyMzgw_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/b444afc02c604183b0a858cf8217e2c1.png