标签：
1.IOC和DI
IOC:Inversion of Control(控制反转)是一个重要的面对对象编程的法则来削减计算机程序的耦合问题，也是轻量级的Spring框架的核心.
IOC理解:将组件对象的控制权从代码本身转移到外部容器,简单来说就是将创建对象实例的控制权从代码控制剥离到IOC容器控制,也就是Spring容器
DI:Dependency Injection(依赖注入)是IOC思想的实现
DI理解:将代码创建对象实例的变成了容器创建,也就是在Spring配置文件里配置类属性,值;然后由容器自动创建对象实例.
代码实现:
1 public class HappySpring { 2 private String info; 3 4 public String getInfo() { 5 return info; 6 } 7 8 public void setInfo(String info) { 9 this.info = info; 10 } 11 12 }
1 <bean id="testbean" class="cn.wa.entity.HappySpring"> 2 <property name="info" value="hellospring" /> 3 </bean>
2.AOP
AOP理解:Aspect Oriented Programming(面向切面编程)将复杂的需求分解出不同方面，将散布在系统中的公共功能集中解决采用代理机制组装起来运行，在不改变原程序的基础上对代码段进行增强处理，增加新的功能.
我的理解是这样的:程序员只关注业务代码块,其他的日志,异常,缓存,事物控制等等交给Spring框架完成,让框架在程序员编写的业务代码块前后做这些事.
代码实现:
1 import java.lang.reflect.Method; 2 3 import org.springframework.aop.MethodBeforeAdvice; 4 5 public class Before implements MethodBeforeAdvice{ 6 7 public void before(Method arg0, Object[] arg1, Object arg2) 8 throws Throwable { 9 System.out.println("方法之前"); 10 } 11 12 } 13 14 }
1 public class Test { 2 3 /** 4 * @param args 5 */ 6 public static void main(String[] args) { 7 ApplicationContext context = new ClassPathXmlApplicationContext( 8 "applicationContext.xml"); 9 Biz biz=(Biz)context.getBean("biz"); 10 biz.add(new HappySpring()); 11 } 12 13 }
1 public class After implements AfterReturningAdvice{ 2 3 public void afterReturning(Object arg0, Method arg1, Object[] arg2, 4 Object arg3) throws Throwable { 5 System.out.println("方法之后"); 6 } 7 8 9 }
1 <bean id="before" class="cn.wa.Before.Before"/> 2 <bean id="after" class="cn.wa.After.After"/> 3 <bean id="biz" class="cn.wa.biz.Biz"/> 4 <aop:config > 5 <aop:pointcut expression="execution(public void *(cn.wa.entity.HappySpring))" id="pointcut"/> 6 <aop:advisor advice-ref="before" pointcut-ref="pointcut"/> 7 <aop:advisor advice-ref="after" pointcut-ref="pointcut"/> 8 </aop:config>
控制台输出:
3.依赖注入的几种方式
构造注入:
1 <!-- 构造注入 --> 2 <bean id="stu1" class="cn.wa.entity.Student"> 3 <constructor-arg index="0" value="吴澳"></constructor-arg> 4 <constructor-arg index="1" value="18"></constructor-arg> 5 </bean>
P命名空间注入:
P命名空间注入域属性注入:
1 <!-- 普通属性注入(set注入) --> 2 <bean id= "car" class="cn.wa.entity.Car"> 3 <property name="color" value="綠色" /> 4 </bean> 5 <bean id="stu" class="cn.wa.entity.Student" scope="prototype"> 6 <property name="info" value="hellospring" /> 7 <!-- 域注入 --> 8 <property name="mycar" ref="car"></property> 9 </bean>
集合注入:
1 <!-- 集合注入 list --> 2 <bean id="list" class="cn.wa.entity.Test"> 3 <property name="list"> 4 <list> 5 <value>测试</value> 6 <value>测试</value> 7 </list> 8 </property> 9 </bean> 10 11 <!-- 集合注入 set --> 12 <bean id="set" class="cn.wa.entity.Test"> 13 <property name="set"> 14 <set> 15 <value>测试</value> 16 <value>测试</value> 17 </set> 18 </property> 19 </bean> 20 21 <!-- 集合注入 map --> 22 <bean id="map" class="cn.wa.entity.Test"> 23 <property name="map"> 24 <map> 25 <entry key="1"> 26 <value>测试</value> 27 </entry> 28 <entry key="2"> 29 <value>测试</value> 30 </entry> 31 </map> 32 </property> 33 </bean>
4.Spring中的代理
Spring中的代理分两种:静态代理和动态代理
静态代理:
1 package cn.wa.test; 2 3 public class ReSubject implements Subject { 4 5 public void eat() { 6 System.out.println("吃饭"); 7 } 8 9 }
1 package cn.wa.test; 2 3 public class TestSubject implements Subject{ 4 private ReSubject sub; 5 public void eat() { 6 System.out.println("洗手"); 7 sub.eat(); 8 System.out.println("洗碗"); 9 } 10 public TestSubject() { 11 this.sub=new ReSubject(); 12 } 13 public ReSubject getSub() { 14 return sub; 15 } 16 public void setSub(ReSubject sub) { 17 this.sub = sub; 18 } 19 20 }
1 package cn.wa.test; 2 3 public class Test { 4 public static void main(String[] args) { 5 TestSubject test=new TestSubject(); 6 test.eat(); 7 } 8 }
简单的静态代理就完成了.
动态代理:
动态代理也分两种:cglib动态代理和jdk动态代理
两者的区别在于jdk动态代理代理的对象必须是实现了接口,而cglib动态代理则不必.
1 public static void main(String[] args) { 2 final Biz biz=new Biz(); 3 Enhancer enhancer=new Enhancer(); 4 enhancer.setSuperclass(biz.getClass()); 5 enhancer.setCallback(new MethodInterceptor() { 6 7 public Object intercept(Object obj, Method method, Object[] arg2, 8 MethodProxy arg3) throws Throwable { 9 System.out.println("增强前"); 10 Object invoke = method.invoke(biz, arg2); 11 System.out.println("增强后"); 12 return invoke; 13 } 14 }); 15 Biz create = (Biz)enhancer.create(); 16 create.delete(); 17 18 }
1 public class Test { 2 public static void main(String[] args) { 3 final Happy info=new HappyImpl(); 4 Happy happy=(Happy)Proxy.newProxyInstance(info.getClass().getClassLoader(), info.getClass().getInterfaces(),new InvocationHandler() { 5 6 public Object invoke(Object obj, Method method, Object[] obj2) 7 throws Throwable { 8 System.out.println("开启事物"); 9 Object invoke = method.invoke(info, obj2); 10 System.out.println("记录日志"); 11 return invoke; 12 } 13 14 }); 15 happy.info(); 16 happy.add(); 17 } 18 }
标签：
原文地址：http://www.cnblogs.com/wuao/p/5945140.html
