美文网首页
Spring框架的IOC和AOP

Spring框架的IOC和AOP

作者: phoebe_gyq | 来源:发表于2017-05-11 22:31 被阅读0次

spring框架

QQ图片20170511202629.png
  1. 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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
    <bean id="orderItem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" >
        <!-----注入变量 名字必须与类中的名字一样------->
        <property name="orderNum" value="order000007"></property>
         <！--注入对象 名字为orderitem，所属的类的应用id为orderItem-->
        <property name="orderitem" ref="orderItem"></property>
    
    --></bean>


</beans>

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!--此时的id就必须与Order.java中所定义的OrderItem的对象名称一样了，不然就会找不到-->
    <bean id="orderitem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" autowire="byName">
        <property name="orderNum" value="order000007"></property>
    </bean>
</beans>

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!--按照byType注入则就与id没有关系，可以随便定义id ！！！但是不能出现多个此类的id-->
    <bean id="orderitdfadafaem" class="org.jia.OrderItem">
        <property name="orderdec" value="item00001"></property>
    </bean>
    <bean id="order" class="org.jia.Order" autowire="byType">
        <property name="orderNum" value="order000007"></property>
    </bean>
</beans>

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

autowire="constructor"

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

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="orderItem" class="org.jia.OrderItem">
<property name="orderdec" value="item00001"></property>
</bean>
<bean id="order" class="org.jia.Order" autowire="constructor">
<property name="orderNum" value="order000007"></property>
</bean>
</beans>

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.通过<aop:config>来配置
4.通过<aop:aspectj-autoproxy>使用AspectJ的注释来表示通知以及切入点


**Spring提供了两种方式实现代理：**
>1.JDKProxy动态代理
2.Cglib
通过**<aop:config>**中的**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

<?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: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">

</beans>

两个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的配置：

<?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: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">

    <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
    <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
    <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
    
    <aop:config>
        <aop:aspect id="time" ref="timeHandler">
            <aop:pointcut id="addAllMethod" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
            <aop:before method="printTime" pointcut-ref="addAllMethod" />
            <aop:after method="printTime" pointcut-ref="addAllMethod" />
        </aop:aspect>
    </aop:config>

</beans>

写一个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");
}

}

<?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: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">

    <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
    <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
    <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
    <bean id="logHandler" class="com.xrq.aop.LogHandler" />
    
    <aop:config>
        <aop:aspect id="time" ref="timeHandler" order="1">
            <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
            <aop:before method="printTime" pointcut-ref="addTime" />
            <aop:after method="printTime" pointcut-ref="addTime" />
        </aop:aspect>
        <aop:aspect id="log" ref="logHandler" order="2">
            <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.*(..))" />
            <aop:before method="LogBefore" pointcut-ref="printLog" />
            <aop:after method="LogAfter" pointcut-ref="printLog" />
        </aop:aspect>
    </aop:config>

</beans>

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

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就好了：
```
<?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: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">
        
        <bean id="helloWorldImpl1" class="com.xrq.aop.HelloWorldImpl1" />
        <bean id="helloWorldImpl2" class="com.xrq.aop.HelloWorldImpl2" />
        <bean id="timeHandler" class="com.xrq.aop.TimeHandler" />
        <bean id="logHandler" class="com.xrq.aop.LogHandler" />
        
        <aop:config>
            <aop:aspect id="time" ref="timeHandler" order="1">
                <aop:pointcut id="addTime" expression="execution(* com.xrq.aop.HelloWorld.print*(..))" />
                <aop:before method="printTime" pointcut-ref="addTime" />
                <aop:after method="printTime" pointcut-ref="addTime" />
            </aop:aspect>
            <aop:aspect id="log" ref="logHandler" order="2">
                <aop:pointcut id="printLog" expression="execution(* com.xrq.aop.HelloWorld.do*(..))" />
                <aop:before method="LogBefore" pointcut-ref="printLog" />
                <aop:after method="LogAfter" pointcut-ref="printLog" />
            </aop:aspect>
        </aop:config>
</beans>
```
表示timeHandler只会织入HelloWorld接口print开头的方法，logHandler只会织入HelloWorld接口do开头的方法

相关文章

  • Spring中的两大核心(Spring是一个IOC和AOP容器框架) IOC与aop IOC(spring的核心思...

  • Spring AOP实战和源码解析

    Spring AOP简介 说起Spring框架，我们最先想到的就是IOC和AOP了，如果说IOC是Spring的核...

  • Java 框架学习之 Spring

    一. Spring 框架介绍。 Spring 框架是 一个基于 IoC 和 AOP 的 J2EE 框架。IoC(控...

  • 2018-08-20

    spring框架中IoC和aop 1. IoC(Inversion of Control) (1) 控制反转:这...

  • Java面试题：Spring IOC容器启动流程附源码

    1. IOC容器概述 IOC和AOP是Spring框架的核心功能，而IOC又是AOP实现的基础，因而可以说IOC是...

  • Spring内存马

    Spring是IOC和AOP的容器框架，SpringMVC则是基于Spring功能的Web框架。Tomcat内存马...

  • Spring

    1、Spring和SpringMVC区别？ Spring是IOC和AOP的容器框架，SpringMVC是基于Spr...

  • 初见spring

    框架 spring IOC AOP 配置文件 IOC/DI 依赖注入（Dependecy Injection） ...

  • Spring和SpringMVC的区别

       Spring是IOC和AOP的容器框架，SpringMVC是基于Spring功能之上添加的Web框架，想用S...

  • Spring源码分析（六）SpringAOP实例及标签的解析

    前言 Spring的IOC和AOP称之为Spring框架的两个核心。AOP是什么？AOP原理是什么？本章节开始，我...

网友评论

      本文标题：Spring框架的IOC和AOP

      本文链接：https://www.haomeiwen.com/subject/dklatxtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|Spring框架的IOC和AOP|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！