1、开闭原则

面向对象编程：

（1）对修改关闭（尽量不要修改源码）
（2）对扩展开放

2、容器

能取出和放入对象的东西

3、Bean

容器中放入的东西

4、spring xml

<bean id="boy1" class="com.alipay.demo.CalabashBoy">（实例化）
    <property name="name"（找set方法） value="大娃"/>（注入属性）
    <property name="hp" value="100"/>
    <property name="color" value="RED"/>
    <property name="skill" ref="strengthSkill"/>
</bean>

5、spring的缺点

比直接写程序调试稍微麻烦，由编译异常变成运行时异常。因为xml是只有跑起来才会解析的。

6、IoC和DI

IoC：控制反转，本来作为一个实体类，自己的东西（属性）应该自己操心，但是现在只提供一个 get/set 组，由别人来管，自己变成了一个pojo。这样就反转了资源控制。

DI：实体类依赖容器来注入。

7、依赖注入常用知识点

8、Bean实例化的方式

9、Bean注入方式

spring注入方式分为两种：
（1）设值注入
（2）构造注入

关于Java构造函数，这里需要补充一下：

（1）java中每个类都有一个默认的无参构造方法。

（2）也可以显示的写出无参构造方法，并可以在方法中做一些操作

（3）如果不显示的写出无参构造方法，而写出带参的构造方法，默认的无参构造方法就会被其覆盖。

10、特殊注入方式

第一个是一个内部bean，这个是只有自己用到，如果是大家都要用到的话，就在外面构造，大家都可以引用。

11、自动绑定

默认是byName，最好也是明确指定的byName

12、Bean的作用域

spring中的bean都是单例

不要把处理的过程性的数据放入对象的私有属性中，不同线程中，同一个对象提供服务，易出现问题，会互相覆盖。但是方法体类的变量没关系，这个函数栈是单个线程独享。

13、Bean的生命周期

spring 提供了很多容器的钩子：本来单个对象应该对容器一无所知才对，但是有的时候bean希望和容器做一些必要的交互。如：销毁时告诉一下自己，或拿到容器信息。

BeanNameAware就可以拿到spring的名字了，如想拿到如下的 boy1。

<bean id="boy1" class="com.alipay.demo.CalabashBoy">
    <property name="name" value="大娃"/>
    <property name="hp" value="100"/>
    <property name="color" value="RED"/>
       <property name="skill" ref="strengthSkill"/>
</bean>

但是spring原则应该是非入侵，尽量不要用spring的东西，尽量是pojo

多是构造的方法（无参），destroy相对用的少。如（两种方法），最好是第一种，不耦合spring：

自定义销毁用的不多：

14、Bean的依赖

一般是用ref来注入自动实现

15、延迟初始化

16、Bean定义的继承

定义一个父类Bean

17、关于想监视葫芦娃的一举一动的例子

让对象不感知到自己被监视

注意几个点：
（1）代理类是继承葫芦娃，这意味着他就是一个葫芦娃类，因为要放到容器中给别人看不出。
（2）这个葫芦娃内部包含了一个葫芦娃对象。

18、Java的动态代理

spring提供代理工厂

<bean id="boy2" class="org.springframework.aop.framework.ProxyFactoryBean">
    <property name="target" ref="boy2Target"/>
    <property name="interceptorNames">
        <list>
            <value>monitorInterceptor</value>
        </list>
    </property>
</bean>

通过拦截器来拦截动作。

不用写明代理类型了

private CalabashBoy target;

拦截器类代码：

/**
 * 用来监视的拦截器。
 * 
 * @author hui.shih
 * @version $Id: MonitorIntrceptor.java, v 0.1 2014-4-27 下午02:55:50 hui.shih Exp $
 */
public class MonitorInterceptor implements MethodInterceptor{

    /** 魔镜客户端 */
    private MagicMirrorClient magicMirrorClient;

    /** 
     * @see org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept.MethodInvocation)
     */
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Object target = invocation.getThis();
        //这里只对CalabashBoy.useSkill进行处理，其他直接放过
        if(target instanceof CalabashBoy || "useSkill".equals(invocation.getMethod().getName())){
            CalabashBoy calabashBoy=(CalabashBoy)target;

            //1.目标方法执行前
            if(calabashBoy.getSkill()!=null){
                magicMirrorClient.send(calabashBoy.getName()+"要发威了，大家快躲起来啊！");
            }
            //2. 执行真正的目标方法
            Object result = invocation.proceed();

            //3.目标方法执行后
            if(calabashBoy.getSkill()!=null){
                magicMirrorClient.send(calabashBoy.getName()+"技能冷却中，大家可以出来了！");
            }
            System.out.println();
            return result;

        }else{
            return invocation.proceed();
        }

    }

    /**
     * Setter method for property <tt>magicMirrorClient</tt>.
     * 
     * @param magicMirrorClient value to be assigned to property magicMirrorClient
     */
    public void setMagicMirrorClient(MagicMirrorClient magicMirrorClient) {
        this.magicMirrorClient = magicMirrorClient;
    }


}

理论上拦截所有的方法，但是只对特定需要的地方进行处理。

但更多的是用 BeanNameAutoProxyCreator：

<bean  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
    <property name="interceptorNames">
        <list>
            <value>monitorInterceptor</value>
            <value>timerInterceptor</value>方法调用时间
        </list>
    </property>
    <property name="beanNames">
        <list>
            <value>boy1</value>
            <value>boy3</value>
        </list>
    </property>
</bean>

拦截器是按先后顺序嵌套

19、AOP相关概念

拦截器就是把通用的操作集中到一起，而且业务方法不知道

用表达式拦截：

<aop:config>
        <aop:pointcut id="pointCut" expression="execution(* com.alipay.demo.CalabashBoy.useSkill(..))" />

        <aop:aspect ref="timerAspect">
            <aop:around method="timingAround" pointcut-ref="pointCut"/>
        </aop:aspect>

        <aop:aspect ref="monitorAspect">
            <aop:before method="monitorBefore" pointcut-ref="pointCut"/>
            <aop:after method="monitorAfter" pointcut-ref="pointCut"/>
            <aop:after-returning method="monitorAfterReturning" returning="success" pointcut-ref="pointCut"/>
        </aop:aspect>
    </aop:config>

可以before、after

每一个中间的拦截器都不是拿的真实目标，都是被欺骗对象

为什么要一层包一层呢？

因为每一层是结合比较紧密的，紧耦合就放在一起。而且每层拦截器都是解耦的。

20、补充