Spring框架的IOC和AOP

spring框架

QQ图片20170511202629.png

Ioc(Inversion of Control)控制反转，在spring中BeanFactory是Ioc容器的核心借口，负责实例化，定位，配置应用程序中的对象以及建立这些对象间的依赖。XmlBeanFactory实现BeanFactory接口，通过获取xml配置文件数据，组成应用对象以及对象间的依赖关系。
三种注入方式:

（1）接口注入（不推荐）
（2）构造方法注入（死的应用）
（3）get、set方式注入（常用）

(1)、 get、set的自动安装，注入方式：

autowire="defualt"
autowire=“byName”
autowire="bytype"'

例如：有两个类需要注入：

package org.jia;
  
  public class Order {
     private String orderNum;
    @SuppressWarnings("unused")
      private OrderItem orderitem;
  
      public OrderItem getOrderitem() {
         return orderitem;
     }
 
     public void setOrderitem(OrderItem orderitem) {
         this.orderitem = orderitem;
     }
 
     public String getOrderNum() {
         return orderNum;
     }
 
     public void setOrderNum(String orderNum) {
         this.orderNum = orderNum;
     }
     
}

package org.jia;
 
 public class OrderItem {
     private String orderdec;

     public String getOrderdec() {
         return orderdec;
    }

    public void setOrderdec(String orderdec) {
         this.orderdec = orderdec;
     }
}

getter&&setter方式第一种注入：defualt





    
        
    
    
        
        
         <！--注入对象 名字为orderitem，所属的类的应用id为orderItem-->
        
    
    -->

getter&&setter方式第二种注入：byName

getter&&setter方式第三种注入：byType

(2)、关于构造器的注入：

autowire="constructor"

                                orderitem = item;
                                         }```
需要在Order.java中加入一个构造器

2.***aop***---代理
     **Spring Security**为spring Security为spring应用提供了生命式的安全机制。
    **Spring Boot**通过大量使用自动配置技术，可以取消大量的XML配置文件，同时该框架提出了starter的概念，用于简化pom文件。可以参考我的一系列博文：
### [《Spring Boot Cookbook》阅读笔记](http://www.jianshu.com/p/5ac18abc91f0)

**aop 应用场景：**
>Authentication 权限
Caching 缓存
Context passing 内容传递
Error handing 错误处理
Lazy loading 懒加载
Debugging 调试
logging 、tracing 、profiling and monitoring记录跟踪 优化校准
Performance optimization 性能优化
Persistence 持久化
Resource pooling 资源池
Synchronization 同步
Transaction 事务


**如何使用Spring AOP**
>1.配置ProxyFactory，显式的设置advisors、advice、target等
2.配置AutoProxyCreator，
3.通过来配置
4.通过使用AspectJ的注释来表示通知以及切入点


**Spring提供了两种方式实现代理：**
>1.JDKProxy动态代理
2.Cglib
通过****中的**proxy-target-class**属性判断，如果该属性**被省略**或者为**false**---基于接口的代理起作用；如果该属性为**true**---基于类代理将起作用。


Spring中的AOP代理由Spring的IOC容器负责生成、管理，其依赖关系也有IOC容器负责管理。因此，AOP代理可以直接使用容器中的其他bean实例作为目标，这种关系可以由IOC容器的依赖注入提供。Spring创建代理的规则为：

1、默认使用Java动态代理来创建AOP代理，这样就可以为任何接口实例创建代理了

2、当需要代理的类不是代理接口的时候，Spring会切换为使用CGLIB代理，也可强制使用CGLIB

AOP编程其实是很简单的事情，纵观AOP编程，程序员只需要参与三个部分：

1、定义普通业务组件

2、定义切入点，一个切入点可能横切多个业务组件

3、定义增强处理，增强处理就是在AOP框架为普通业务组件织入的处理动作

**所以进行AOP编程的关键就是定义切入点和定义增强处理，一旦定义了合适的切入点和增强处理，AOP框架将自动生成AOP代理，即：代理对象的方法=增强处理+被代理对象的方法。**


以下为简单实例：
aop.xml

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
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-4.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.2.xsd">

两个jar包：

1、aopalliance.jar

2、aspectjweaver.jar

开始讲解用Spring AOP的XML实现方式，先定义一个接口：

public interface HelloWorld
{
void printHelloWorld();
void doPrint();
}


定义两个接口实现类：

public class HelloWorldImpl1 implements HelloWorld
{
public void printHelloWorld()
{
System.out.println("Enter HelloWorldImpl1.printHelloWorld()");
}

public void doPrint()
{
    System.out.println("Enter HelloWorldImpl1.doPrint()");
    return ;
}

}

public class HelloWorldImpl2 implements HelloWorld
{
public void printHelloWorld()
{
System.out.println("Enter HelloWorldImpl2.printHelloWorld()");
}

public void doPrint()
{
    System.out.println("Enter HelloWorldImpl2.doPrint()");
    return ;
}

}

横切关注点，这里是打印时间：

public class TimeHandler
{
public void printTime()
{
System.out.println("CurrentTime = " + System.currentTimeMillis());
}
}

有这三个类就可以实现一个简单的Spring AOP了，看一下aop.xml的配置：

写一个main函数调用一下：

public static void main(String[] args)
{
ApplicationContext ctx =
new ClassPathXmlApplicationContext("aop.xml");

HelloWorld hw1 = (HelloWorld)ctx.getBean("helloWorldImpl1");
HelloWorld hw2 = (HelloWorld)ctx.getBean("helloWorldImpl2");
hw1.printHelloWorld();
System.out.println();
hw1.doPrint();

System.out.println();
hw2.printHelloWorld();
System.out.println();
hw2.doPrint();

}

运行结果为：

CurrentTime = 1446129611993
Enter HelloWorldImpl1.printHelloWorld()
CurrentTime = 1446129611993

CurrentTime = 1446129611994
Enter HelloWorldImpl1.doPrint()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.printHelloWorld()
CurrentTime = 1446129611994

CurrentTime = 1446129611994
Enter HelloWorldImpl2.doPrint()
CurrentTime = 1446129611994

看到给HelloWorld接口的两个实现类的所有方法都加上了代理，代理内容就是打印时间
**基于Spring的AOP使用其他细节**
1、增加一个横切关注点，打印日志，Java类为：

public class LogHandler
{
public void LogBefore()
{
System.out.println("Log before method");
}

public void LogAfter()
{
    System.out.println("Log after method");
}

}

测试类不变，打印结果为：

CurrentTime = 1446130273734
Log before method
Enter HelloWorldImpl1.printHelloWorld()
Log after method
CurrentTime = 1446130273735

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl1.doPrint()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273736
Log before method
Enter HelloWorldImpl2.printHelloWorld()
Log after method
CurrentTime = 1446130273736

CurrentTime = 1446130273737
Log before method
Enter HelloWorldImpl2.doPrint()
Log after method
CurrentTime = 1446130273737

要想让logHandler在timeHandler前使用有两个办法：

（1）aspect里面有一个order属性，order属性的数字就是横切关注点的顺序

（2）把logHandler定义在timeHandler前面，Spring默认以aspect的定义顺序作为织入顺序

2、我只想织入接口中的某些方法

修改一下pointcut的expression就好了：
```


        
        
        
        
        
        
        
            
                
                
                
            
            
                
                
                
            
        

```
表示timeHandler只会织入HelloWorld接口print开头的方法，logHandler只会织入HelloWorld接口do开头的方法

Spring框架的IOC和AOP

spring框架

你可能感兴趣的:(Spring框架的IOC和AOP)