Spring IOC和aop的原理及实例详解

2019-11-26 08:20:20

字体：大中小

来源：转载

供稿：网友

这篇文章主要介绍了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实现类没有贴出来，就是打印一句话出来表现方法执行了。

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; }}

以上代码简单的实现了一个动态代理，并执行了自己的一段逻辑。

那么aop是如何实现切面编程的呢，就是通过动态代理。当然这也是spring来实现的，而我们需要做的就是知道如何编写编织语法。