SpringIOC和AOP理解之深入浅出（建议收藏）
Spring框架介绍
概念：Spring是一个开源的框架，并且是一个轻量级的java开发框架
前身：interface21是他的前身
Spring理念：使现有的技术更加容易使用，本身就是一个大杂烩，整合了现有的主流技术框架
优点：
- 方便解耦，简化开发 （高内聚低耦合）
Spring就是一个大工厂（容器），可以将所有对象创建和依赖关系维护，交给Spring管理
spring工厂是用于生成bean - AOP编程的支持
Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 - 声明式事务的支持
只需要通过配置就可以完成对事务的管理，而无需手动编程 - 方便程序的测试
Spring对Junit4支持，可以通过注解方便的测试Spring程序 - 方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持 - 降低JavaEE API的使用难度
Spring 对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低 - Spring是一个开源的免费框架（容器）
- Spring是一个轻量级的，非入侵式的框架
- Spring支持事务的处理，对框架的整合的支持
- 总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架
控制反转（IOC容器）
IOC原型：
之前： userDao 接口 userDaoImpl实现类 userService业务接口 userServiceImpl业务实现类
缺点： 代码量大，修改成本高，若是多个业务需要频繁修改对象
解决： 在userServiceImpl使用set注入来被动创建对象
区别： 之前是程序主动创建对象，是程序员来控制的。现在使用set注入后不在具有主动性，变成了被动接收对象，不用再修改业务模块的代码
优点： 这种思想本质上的解决了问题，程序员不需要再管理对象的创建，系统的耦合性大大降低，更加专注于业务的实现上。
IOC本质：
1.控制反转loC(Inversion of Control),是一种设计思想，DI(依赖注入)是实现IoC的一种方法
2.没有loC的程序中,我们使用面向对象编程,对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，
3.控制反转是一种通过描述(XML或注解)并通过第3方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器,其实现方法是依赖注入(Dependency Injection,DI)
接下来由一个小案例让大家感受一下IOC
案例：HelloSpring
两个Dao层实现类，一个业务层实现类由spring创建并统一管理
业务层实现类对象含有Dao实现类的对象参数
由spring创建并统一管理后，直接操作xml文件即可修改获取的对象，对象统一管理创建，无须在硬代码中频繁创建对象，耦合性极大降低。
总结：
●hello对象是由谁创建的？
hello对象是由Spring创建的
●Hello 对象的属性是怎么设置的?
hello对象的属性是由Spring容器设置的，
这个过程就叫控制反转:
控制: 谁来控制对象的创建？传统应用程序的对象是由程序本身控制创建的，使用Spring后,对象是由Spring来创建
反转: 程序本身不创建对象,而变成被动的接收对象.
依赖注入: 就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收.
OK,到了现在,我们彻底不用再程序中去改动了,要实现不同的操作,只需要在xm|配置文件中进行修改
所谓的IoC, 一句话搞定对象由Spring来创建，管理，装配!
注意： 在配置文件加载的时候，也就使用getBean的时候，容器中的对象就已经初始化了！
接下来讲解一下IOC的几种注入方式
Bean的配置
1.关于bean的配置：
id : bean的唯一标识符，也就是相当于对象的引用
class : bean对象所对应的类:包名+类型
name : 也是别名,而且name可以同时取多个别名
例子：
2.关于import的配置：
import一般用于团队开发使用，他可以将多个配置文件，导入合并为一个；
IOC------依赖注入
- 普通值注入
<property name="name" value="刘大帅"/>
- bean注入
<property name="hello" ref="hello">property>
- 数组注入
<property name="books">
<array>
<value>西游记value>
<value>水浒传value>
<value>红楼梦value>
array>
property>
- list集合注入
<property name="hobbys">
<list>
<value>玩游戏value>
<value>听音乐value>
list>
property>
- list集合注入
<property name="hobbys">
<list>
<value>玩游戏value>
<value>听音乐value>
list>
property>
- map集合注入
<property name="card">
<map>
<entry key="身份证" value="123123">entry>
<entry key="手机哈" value="12311">entry>
map>
property>
- properties配置文件注入
<property name="info">
<props>
<prop key="学号">JX200201prop>
props>
property>
IOC------拓展注入
- p命名空间注入，可以直接注入属性的值: property
<bean id="user2" class="com. kuang . pojo.User" p:name=" 秦疆" p:age="18"/>
- c命名空间注入，通过构造器注入: construct-args
<bean id="user2" class="com. kuang . pojo.User" c:age="18" c:name="伟伟"/>
Bean的作用域
1.单例模式(Spring默认机制)-(singleton)
<bean id="user2" class="com. kuang. pojo.User" c:age="18" c:name="伟伟" scope="singleton"/>
2.原型模式:每次从容器中get的时候，都会产生一新对象!(prototype)
<bean id="accountservice" class="com. something. DefaultAccountservice" scope="prototype"/>
3.其余的request. session. application. 这些个只能在web开发中使用到!
IOC------Bean的自动装配
1.ByName自动装配：byName:会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanid
<bean id="people" class="com. kuang. pojo. People" autowire="byName">
<property name="name" Value=" 小伟伟呀"/>
bean>
2.ByType自动装配： byType:会自动在容器上下文中查找，和自己对象属性类型相同的bean
<bean class="com. kuang. pojo.Cat"/>
<bean class="com. kuang. pojo.Cat"/>
<bean id="peop1e" class="com. kuang. pojo. People" autowi re="byType">
<property name="name" value="小伟伟呀"/>
bean>
小结:
●byname的时候，需要保证所有bean的id唯一， 并且这个bean需要和自动注入的属性的set方法的值一致!
●bytype的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注 入的属性的类型一致!
IOC------注解实现自动装配
要使用注解须知:
- 导入约束: context约束
- 配置注解的支持: context annotation-config. [重要]
方式
- 指定要主描的包，这个包下的注解就会生效
<context:component-scan base-package="com.kuang.pojo" /> <context:annotation-config/>
- @component
@Component 组件等价于<bean id= "user" class= "com. kuang. pojo. User"/>
@Component:组件放在类上，说明这个类被Spring管理了，就是bean；
- @Component有几个衍生注解，我们在web开发中，会按照mvc三层架构分层;
dao [@Repository]
service [@Service]
servlet [ @Controller]
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，进行装配
作用域注解： @Scope("")
4. @Autowired
直接在属性.上使用即可!也可以在set方式上使用!
使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC(Spring) 容器
注意：
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解[@Autowired] 完成的时候、我们可以使用@Qualifier(value=“xx”)去配置@Autowired的使用，指定一个唯一的bean对象注入!
pub1ic class People {
@Autowired
@qualifier(value="cat111")
private cat cat;
@Autowired
@qualifier(value=" dog222")
private Dog dog;
}
总结：
@Resource和@ Autowired的区别:
●都是用来自动装配的，都可以放在属性字段上
●@ Autowired通过byType的方式实现，而且必须要求这个对象存在! [常用]
●@ Resource默认通过byname的方式实现，如果找不到名字，则通过byType实现! 如果两个都找不到的情况下，就报错!
xml与注解：
xml 更加万能,适用于任何场合! 维护简单方便；
注解不是自己类使用不了，维护相对复杂。
xml与注解最佳实践：
xml用来管理bean；
注解只负责完成属性的注入；
我们在使用的过程中，只需要注意一个问题: 必须让注解生效,就需要开启注解的支持
SpringAOP（面向切面编程）
官方概念： AOP，即面向切面编程，可以说是OOP（Object Oriented Programming，面向对象编程）的补充和完善。OOP引入封装、继承、多态等概念来建立一种对象层次结构，用于模拟公共行为的一个集合。不过OOP允许开发者定义纵向的关系，但并不适合定义横向的关系。
例如日志功能。日志代码往往横向地散布在所有对象层次中，而与它对应的对象的核心功能毫无关系对于其他类型的代码，如安全性、异常处理和透明的持续性也都是如此，这种散布在各处的无关的代码被称为横切在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。
AOP技术恰恰相反，它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。
个人理解：
1.首先，AOP是OOP面向对象开发的扩展补充：面向切面编程。因为正常开发流程中为OOP纵向开发，由dao-service-servlet-web，当我们需要对其中一个模块进行添加其他额外功能时，此时为横向开发，已经不适用于使用OOP思想开发。为了不修改原有代码，减小耦合性，便使用到了AOP横向开发。他将需要扩展的定义为一个切面，对其进行添加想要的功能。
2.在实现面向切面编程中，使用了代理模式，代理模式是将要扩展的功能交给代理对象来操作。
首先要使用反射包中的InvocationHandler：用来执行代理对象的方法 Proxy：用来获取代理实例
（而Spring对AOP提供了支持，Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理）
Spring对AOP的支持
Spring中AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也由IOC容器负责管理。因此，AOP代理可以直接使用容器中的其它bean实例作为目标，这种关系可由IOC容器的依赖注入提供。
Spring创建代理的规则为：
1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了
2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB
AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：
- 定义普通业务组件
- 定义切入点，一个切入点可能横切多个业务组件
- 定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作
所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。
Aop在Spring中的作用
提供声明式事务;允许用户自定义切面
横切关注点: 跨越应用程序多个模块的方法或功能。即是,与我们业务逻辑无关的,但是我们需要关注的部分,就是横切关注点。如日志,安全,缓存,事务等等
切面(ASPECT) : 横切关注点被模块化的特殊对象。即，它是一个类。
通知(Advice) : 切面必须要完成的工作。即,它是类中的一个方法
目标(Target) : 被通知对象
代理(Proxy) : 向目标对象应用通知之后创建的对象
切入点(PointCut) : 切面通知执行的"地点"的定义。
连接点(JointPoint) : 与切入点匹配的执行点
Aop实现方式
注意：使用AOP织入，需要导入依赖包
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
方式一：使用Spring API接口
<--方式一:使用原生:Spring API接口1-->
<!--配置aop:需要导入aop的约束-->
<aop:config>
<!--切入点:expression:表达式execution( 要执行的位置! *****-->
<aop:pointcut id=" pointcut" expression="execution(* com.kuang.service.UserServiceImp1.*(..))"/>
<!--执行环绕增加! -->
<aop:advisor advice-ref="log" pointcut-ref=" pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
方式二：自定义来实现AOP
自定义的类：
public class DiyPointCut {
public void before( ){
System. out . print1n("=======方法执行前========");
}
public void |after(){
System. out . print1n("=======方法执行后========");
}
}
<!--自定义类-->
<bean id="diy" class="com. kuang. diy.DiyPointCut"/>
<aop :config>
<!--自定义切面，ref 要引用的类-->
<aop:aspect ref="diy">
<!--切入点-->
<aop:pointcut id=" point" expression=" execution(*com.kuang.service.UserServiceImp1.*(..))"/>
<!--通知-->
<aop: before method= "before" pointcut-ref="point"/>
<aop:after method="after" pointcut -ref="point"/>
</aop:aspect>
</aop : config>
方式三：使用注解实现
@Aspect //标注这个类是一个 切面
public class AnnotationPointCut {
@Before("execution(* com. kuang. service.UserServiceImp1.*(..))")
public void before(){
System. out. println("=====方法执行前=====");
}
@After("execution(* com. kuang. service . UserServiceImp1.*(..))")
public void after(){
System. out. print1n("=====方法执行后=====");
}
//在环绕增强中，我们可以给定一个参数， 代表我们要获取处理切入的点;:
@Around("execution(* com. kuang. service . UserServiceImp1. *(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.print1n("环绕前");
Signature signature = jp.getSignature();//获得签名
System.out.println("signature :"+signature);
object proceed = jp.proceed(); //执行方法
System.out.print1n("环绕后");
System.out.println( proceed);
}
<bean id=" annotationPointCut" class=" com. kuang. diy . AnnotationPointCut"/>
<!--开启注解支持! JDK(默认 proxy-target-class= "false") cglib (proxy-target-class="true") -->
<aop: aspectj-autoproxy proxy-target-class= "true"/>
代理模式
优点:
●可以使真实角色的操作更加纯粹 不用去关注一些公共的业务
●公共也就就交给代理角色!实现了业务的分工
●公共业务发生扩展的时候，方便集中管理
缺点:
●一个真实角色就会产生一个代理角色;代码量会翻倍 ，开发效率会变低
AOP面向切面编程-----代理模式
- 静态代理
角色分析：
抽象角色：一般会使用接口或者抽象类来解决；
真实角色：被代理的角色；
代理角色：代理真实角色，代理真实角色后,我们一般会做一些附属操作；
客户：访问代理对象的人。 - 动态代理
动态代理和静态代理角色一样；
动态代理的代理类 是动态生成的，不是我们直接写好的；
动态代理分为两大类：
基于接口：JDK动态代理；
基于类：cglib；
java字节码实现：javasist。
以下是AOP理解小案例
//动态代理的写法
//等我们会用这个类，自动生成代理类!
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成得到代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);
}
//处理代理实例，并返回结果
public object invoke(object proxy, Method method, object[] args) throws Throwable {
|
//动态代理的本质，就是使用反射机制实现!
Object result =method.invoke(rent, args);
seeHouse();
return result;
fare();|
}
public void seeHouse(){
System. out . print1n("中介带看房子");
}
public void fare(){
System.out.print1n("收中介费");
}
}
//主函数调用
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host( ) ;
//代理角色:现在没有
ProxyInvocationHandler pih = new ProxyInvocationHand1er() ;
//通过调用程序处理角色来处理我们要调用的接口对象!
pih. setRent(host);
Rent proxy = (Rent) pih. getProxy();
proxy .rent();
}
}
以上是我个人对spring AOP IOC的的个人理解 ， 希望大家多多探讨一起学习交流~
个人推荐优秀文章：
文章1
文章2