Spring IOC和aop的原理及實例詳解

更新時間：2019年11月16日 10:19:13 作者：我看見的世界

這篇文章主要介紹了Spring IOC和aop的原理及實例詳解,文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值,需要的朋友可以參考下

Spring是一個輕量級的控制反轉(IoC)和面向切面(AOP)的容器框架。特點是面向接口編程，松耦合。

1：IOC（控制反轉）別名（DI:依賴注入）

首先來一段ioc的實現原來代碼：

public class ClassPathXmlApplicationContext implements BeanFactory {
 
 private Map<String , Object> beans = new HashMap<String, Object>();
 
 //IOC Inverse of Control DI Dependency Injection
 public ClassPathXmlApplicationContext() throws Exception {
  SAXBuilder sb=new SAXBuilder();
  //解析xml配置文件
  Document doc=sb.build(this.getClass().getClassLoader().getResourceAsStream("beans.xml"));
  Element root=doc.getRootElement(); //獲取根元素
  List list=root.getChildren("bean");//根元素下的子元素
  for(int i=0;i<list.size();i++) {
   Element element=(Element)list.get(i);
   String id=element.getAttributeValue("id");
   String clazz=element.getAttributeValue("class");
   Object o = Class.forName(clazz).newInstance(); //反射獲得實例
   System.out.println(id);
   System.out.println(clazz);
   beans.put(id, o);
   //注入bean屬性
   for(Element propertyElement : (List<Element>)element.getChildren("property")) {
    String name = propertyElement.getAttributeValue("name"); //userDAO
    String bean = propertyElement.getAttributeValue("bean"); //u
    Object beanObject = beans.get(bean);//UserDAOImpl instance
    
    String methodName = "set" + name.substring(0, 1).toUpperCase() + name.substring(1);
    System.out.println("method name = " + methodName);
    
    Method m = o.getClass().getMethod(methodName, beanObject.getClass().getInterfaces()[0]);
    m.invoke(o, beanObject); 
   }
  } 
 }

 public Object getBean(String id) {
  return beans.get(id);
 }
}

//xml文件
<beans>
 <bean id="u" class="com.bjsxt.dao.impl.UserDAOImpl" />
 <bean id="userService" class="com.bjsxt.service.UserService" >
  <property name="userDAO" bean="u"/>
 </bean>
 
</beans>

以上代碼實現了將UserDAOImpl注入到userService.

值得注意的是：以上操作都是spring幫我們實現的，我們只需要理解如何配置即可。

spring還提供了bean的生存周期和范圍屬性：

scope:singleton(單例，即每次調用的對象都為同一個)。 prototype（原型，即以bean對象為原型，每次new一個新對象出來）

init-method="init" destroy-method="destroy" lazy-init="true"(延遲初始化bean，即spring啟動時，不初始化bean，當需要使用時才實例化，作用：但spring啟動緩慢時可使用)

現在基本都是用注解實現，但只要能明白spring是如何實現bean的注入，基本原理都是一樣的。spring在中間的作用就是幫我們實現元素之前的注入，誰注入到誰就需要用到不同的注解了。

AOP(切面編程)

首先還是先來一段代碼

定義一個InvocationHandler的實現類

public class UserServiceTest {

 @Test
 public void testAdd() throws Exception {
  BeanFactory applicationContext = new ClassPathXmlApplicationContext();

  UserService service = (UserService)applicationContext.getBean("userService");
   
  User u = new User();
  u.setUsername("zhangsan");
  u.setPassword("zhangsan");
  service.add(u);
 }
 
 @Test
 public void testProxy() {
  UserDAO userDAO = new UserDAOImpl();
  LogInterceptor li = new LogInterceptor();
  li.setTarget(userDAO);
  UserDAO userDAOProxy = (UserDAO)Proxy.newProxyInstance(userDAO.getClass().getClassLoader(), userDAO.getClass().getInterfaces(), li);
  
  userDAOProxy.delete();
  userDAOProxy.save(new User());
 }

調用測試類，service和DAO實現類沒有貼出來，就是打印一句話出來表現方法執(zhí)行了。

public class LogInterceptor implements InvocationHandler {
 private Object target;
 public Object getTarget() {
  return target;
 }
 public void setTarget(Object target) {
  this.target = target;
 }

 public void beforeMethod(Method m) {
  System.out.println(m.getName() + " start");
 }

 @Override
 public Object invoke(Object proxy, Method m, Object[] args)
   throws Throwable {
  beforeMethod(m);
  m.invoke(target, args);
  return null;
 }
}

以上代碼簡單的實現了一個動態(tài)代理，并執(zhí)行了自己的一段邏輯。

那么aop是如何實現切面編程的呢，就是通過動態(tài)代理。當然這也是spring來實現的，而我們需要做的就是知道如何編寫編織語法。