Spring回顾

Posted 2020-08-14

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>

DI,IOC实现

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>

List,Set,Map集合注入

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 }

A类

 

 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 }

B类

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     }

cglib动态代理

 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 }

jdk动态代理