spring的ioc和aop

IOC–inverse of control控制反转
在传统的开发中，对象的创建是由程序猿根据程序逻辑来创建的，使用了spring以后，对象的创建交给spring的容器来完成。容器的创建好对象后，会自动将对象设置到指定的位置。创建对象的控制权限由程序猿变成了spring容器。这种控制权限的转移，称为控制反转。由传统的主动式编程变为被动式编程。

---

代码：
User类：

public class User {    private String name;    private int age;    public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public int getAge() {        return age;    }    public void setAge(int age) {        this.age = age;    }}

spring配置文件

<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd">    <bean id="user" class="cn.zwq.vo.User">        <property name="name" value="张三"/>        <property name="age" value="22"/>    </bean></beans>

测试：

public static void main(String[] args) {        //启动容器        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");        //从容器中获取对象        User user = (User)ac.getBean("user");        System.out.println(user.getName()+"----"+user.getAge());    }

下面我简单陈述一下我自己的理解：ioc的机制就是将生成对象的过程交给第三方的容器进行处理，利用反射的机制生成对象，全部的控制权都交给了第三方，第三方的容器起到了类似于粘合剂的作用。如此一来，对象与对象之间，耦合的程度也得到了降低。

DI的理解：依赖注入是类与类之间不再是以硬编码的方式耦合在一起，而是以配置文件组织在一起。

---

AOP：aspect orentied programming–面向切面编程
首先简单陈述一下我自己的理解：在不改变原有代码的前提下，为程序增加新的功能。

spring的aop的应用：声明式事务，自定义AOP

增加日志处理：
log类：

/** * 切面实现spring提供的 api。实现了前置通知。 * */public class Log implements MethodBeforeAdvice{    @Override    public void before(Method method, Object[] args, Object target)            throws Throwable {        System.out.println("info:"+new Date()+"\n "+target.getClass().getName()+"\t"+method.getName());    }}

service层

public class UserServiceImpl implements UserService{    /**     * 在每次实现业务方法时 需要增加一些公共的功能。     * 如：日志,缓存，安全检查,事务等     */    public void save() {        System.out.println("保存用户");    }    public void update() {        System.out.println("更新用户");    }    public void delete() {        System.out.println("删除用户");    }    public void get() {        System.out.println("获取用户");    }}

spring配置文件：

<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">    <bean class="cn.zwq.service.impl.UserServiceImpl"/>    <bean id="log" class="cn.zwq.log.Log"/>    <aop:config>        <!-- 切入点配置             execution 表示 匹配断言的表达式                 第一个* 表示所有返回值                 第二个* 表示impl包下的所有类                第三个* 表示类中的所有方法                (..)括号中的..表示所有参数        -->        <aop:pointcut expression="execution(* cn.zwq.service.impl.*.*(..))" id="pointcut"/>        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>    </aop:config></beans>

测试：

public class Demo {    public static void main(String[] args) {        ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");        UserService userService = ac.getBean(UserService.class);        System.out.println(userService.getClass());        userService.save();    }}

spring对AOP的支持：

说到spring的AOP那就离不开代理模式了。
这里我就不一点点的讲起了，有兴趣的可以去看看我之前的关于静态代理和动态代理的博客。

<aop:aspect>    标签定义横切逻辑，就是要在连接点上做什么<aop:Advisor>   标签定义在哪些连接点应用什么样的<aop:aspect>

Spring根据配置文件中关于Advisor和Pointcut的配置找到所有Advisor，在bean初始化时根据需要为其生成代理。并在生成代理的过程中把advice织入在代理对象里。这应该就是aop的实现原理了。