Spring回顾

1.IOC和DI

IOC:Inversion of Control(控制反转)是一个重要的面对对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心.

IOC理解:将组件对象的控制权从代码本身转移到外部容器,简单来说就是将创建对象实例的控制权从代码控制剥离到IOC容器控制,也就是Spring容器

DI:Dependency Injection(依赖注入)是IOC思想的实现

DI理解:将代码创建对象实例的变成了容器创建,也就是在Spring配置文件里配置类属性,值;然后由容器自动创建对象实例.

代码实现:

public class HappySpring {
    private String info;
    
    public String getInfo() {
        return info;
    }

    public void setInfo(String info) {
        this.info = info;
    }
    
}

<bean id="testbean" class="cn.wa.entity.HappySpring">
        <property name="info" value="hellospring" />
    </bean>

2.AOP

AOP理解:Aspect Oriented Programming(面向切面编程)将复杂的需求分解出不同方面，将散布在系统中的公共功能集中解决采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能.

我的理解是这样的:程序员只关注业务代码块,其他的日志,异常,缓存,事物控制等等交给Spring框架完成,让框架在程序员编写的业务代码块前后做这些事.

代码实现:

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class Before implements MethodBeforeAdvice{

    public void before(Method arg0, Object[] arg1, Object arg2)
            throws Throwable {
        System.out.println("方法之前");
    }

}

}

public class Test {

    /**
     * @param args
     */
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        Biz biz=(Biz)context.getBean("biz");
        biz.add(new HappySpring());
    }

}

public class After implements AfterReturningAdvice{

    public void afterReturning(Object arg0, Method arg1, Object[] arg2,
            Object arg3) throws Throwable {
            System.out.println("方法之后");
    }


}

    <bean id="before" class="cn.wa.Before.Before"/>
    <bean id="after" class="cn.wa.After.After"/>
    <bean id="biz" class="cn.wa.biz.Biz"/>
    <aop:config >
     <aop:pointcut expression="execution(public void *(cn.wa.entity.HappySpring))" id="pointcut"/>
     <aop:advisor advice-ref="before" pointcut-ref="pointcut"/>
     <aop:advisor advice-ref="after" pointcut-ref="pointcut"/>
    </aop:config>

控制台输出:

3.依赖注入的几种方式

构造注入:

<!-- 构造注入 -->
    <bean id="stu1" class="cn.wa.entity.Student">
        <constructor-arg index="0" value="吴澳"></constructor-arg>
        <constructor-arg index="1" value="18"></constructor-arg>
    </bean>

P命名空间注入:

P命名空间注入

域属性注入:

<!-- 普通属性注入(set注入) -->
    <bean id= "car" class="cn.wa.entity.Car">
      <property name="color" value="綠色" />
    </bean>
    <bean id="stu" class="cn.wa.entity.Student" scope="prototype">
        <property name="info" value="hellospring" />
        <!-- 域注入 -->
        <property name="mycar" ref="car"></property>
    </bean>

集合注入:

    <!-- 集合注入 list -->
    <bean id="list" class="cn.wa.entity.Test">
        <property name="list">
         <list>
          <value>测试</value>
          <value>测试</value>
         </list>
        </property>
    </bean>
    
    <!-- 集合注入 set -->
    <bean id="set" class="cn.wa.entity.Test">
        <property name="set">
         <set>
          <value>测试</value>
          <value>测试</value>
         </set>
        </property>
    </bean>
    
    <!-- 集合注入 map -->
    <bean id="map" class="cn.wa.entity.Test">
        <property name="map">
         <map>
          <entry key="1">
          <value>测试</value>
          </entry>
          <entry key="2">
          <value>测试</value>
          </entry>
         </map>
        </property>
    </bean>

4.Spring中的代理

Spring中的代理分两种:静态代理和动态代理

静态代理:

 

package cn.wa.test;

public class ReSubject implements Subject {

    public void eat() {
        System.out.println("吃饭");
    }

}

 

package cn.wa.test;

public class TestSubject implements Subject{
    private ReSubject sub;
    public void eat() {
        System.out.println("洗手");
        sub.eat();
        System.out.println("洗碗");
    }
    public TestSubject() {
        this.sub=new ReSubject();
    }
    public ReSubject getSub() {
        return sub;
    }
    public void setSub(ReSubject sub) {
        this.sub = sub;
    }

}

package cn.wa.test;

public class Test {
 public static void main(String[] args) {
    TestSubject test=new TestSubject();
     test.eat();
}
}

简单的静态代理就完成了.

动态代理:

动态代理也分两种:cglib动态代理和jdk动态代理

 

 

两者的区别在于jdk动态代理代理的对象必须是实现了接口,而cglib动态代理则不必.

    public static void main(String[] args) {
        final Biz biz=new Biz();
        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(biz.getClass());
        enhancer.setCallback(new MethodInterceptor() {
            
            public Object intercept(Object obj, Method method, Object[] arg2,
                    MethodProxy arg3) throws Throwable {
                System.out.println("增强前");
                Object invoke = method.invoke(biz, arg2);
                System.out.println("增强后");
                return invoke;
            }
        });
        Biz create = (Biz)enhancer.create();
        create.delete();
        
    }

public class Test {
 public static void main(String[] args) {
     final Happy info=new HappyImpl();
     Happy happy=(Happy)Proxy.newProxyInstance(info.getClass().getClassLoader(), info.getClass().getInterfaces(),new InvocationHandler() {
        
        public Object invoke(Object obj, Method method, Object[] obj2)
                throws Throwable {
            System.out.println("开启事物");
            Object invoke = method.invoke(info, obj2);
            System.out.println("记录日志");
            return invoke;
        }
            
        });
     happy.info();
     happy.add();
}
}