有关spring的依赖注入和@resource注解的使用

最新推荐文章于 2024-05-27 20:05:16 发布

DING135DING

最新推荐文章于 2024-05-27 20:05:16 发布

阅读量7.3k

点赞数

分类专栏：框架理解文章标签： spring 流程控制框架

框架理解专栏收录该内容

4 篇文章 0 订阅

订阅专栏

控制反转(Inversion of Control)和依赖注入(Dependency Injection)：
IoC，直观地讲，就是容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象地说，即由容器动态地将某种依赖关系注入到组件之中。
依赖注入是指所依赖的对象不是由自己new出来的,而是用别的方式注入的.Spring的依赖注入是在BeanFactory创建bean的时候完成的.通常是在"bean"类中定义了"依赖"(成员变量,type为别的类,最好是interface或者abstract class),BeanFactory通过配置注入这些"依赖"(BeanFactory创建bean的时候赋值给这些成员变量).当这些"依赖"的实现发生变化的时候,不需要修改"bean"类,而只需要修改Spring的配置文件.或者通过配置新的"依赖"实现,实现新的业务而不用修改"bean"类.

通常，在JAVA中为了完成某一个业务的处理，通常要一个流程控制的类调用其它很多辅助的类来完成。传统的编程均要使用像new object()这样的语法来完成要使用的辅助类然后再调用辅助类来完成一个流程中某一个工作。如果因为业务变化，这个辅助类要换成另一个类，就必须在控制流程的类中new()另一个类，对象间的耦合度很高。而IOC的思想是：Spring容器来实现这些相互依赖对象的创建、协调工作。对象只需要关心业务流程逻辑本身就可以了。从这方面来说，对象如何得到他的辅助类对象的责任被反转(IoC)。

获得spring里注册Bean的四种方法，特别是第三种方法，简单：

一：方法一（多在struts框架中）继承BaseDispatchAction

import com.mas.wawacommunity.wap.service.UserManager;

public class BaseDispatchAction extends DispatchAction {
    /**
    * web应用上下文环境变量
    */
    protected WebApplicationContext ctx;

    protected UserManager userMgr;

    /**
    * 获得注册Bean
    * @param beanName String 注册Bean的名称
    * @return
    */
    protected final Object getBean(String beanName) {
        return ctx.getBean(beanName);
    }

    protected ActionForward unspecified(ActionMapping mapping, ActionForm form,
              javax.servlet.http.HttpServletRequest request,
              javax.servlet.http.HttpServletResponse response) {
        return mapping.findForward("index");
    }

    public void setServlet(ActionServlet servlet) {
        this.servlet = servlet;
        this.ctx = WebApplicationContextUtils.getWebApplicationContext(servlet.getServletContext());
        this.userMgr = (UserManager) getBean("userManager");
    }
}

二：方法二实现BeanFactoryAware
一定要在spring.xml中加上:
<bean id="serviceLocator" class="com.am.oa.commons.service.ServiceLocator" singleton="true" />
当对serviceLocator实例时就自动设置BeanFactory,以便后来可直接用beanFactory

public class ServiceLocator implements BeanFactoryAware {
    private static BeanFactory beanFactory = null;

    private static ServiceLocator servlocator = null;

    public void setBeanFactory(BeanFactory factory) throws BeansException {
        this.beanFactory = factory;
    }

    public BeanFactory getBeanFactory() {
        return beanFactory;
    }


    public static ServiceLocator getInstance() {
        if (servlocator == null)
              servlocator = (ServiceLocator) beanFactory.getBean("serviceLocator");
        return servlocator;
    }

    /**
    * 根据提供的bean名称得到相应的服务类
    * @param servName bean名称
    */
    public static Object getService(String servName) {
        return beanFactory.getBean(servName);
    }

    /**
    * 根据提供的bean名称得到对应于指定类型的服务类
    * @param servName bean名称
    * @param clazz 返回的bean类型,若类型不匹配,将抛出异常
    */
    public static Object getService(String servName, Class clazz) {
        return beanFactory.getBean(servName, clazz);
    }
}

action调用:

public class UserAction extends BaseAction implements Action,ModelDriven{

    private Users user = new Users();
    protected ServiceLocator service = ServiceLocator.getInstance();
    UserService userService = (UserService)service.getService("userService");

    public String execute() throws Exception {
        return SUCCESS;
    }

public Object getModel() {
        return user;
    }

    public String getAllUser(){
        HttpServletRequest request = ServletActionContext.getRequest();
        List ls=userService.LoadAllObject( Users.class );
        request.setAttribute("user",ls);
        this.setUrl("/yonghu.jsp");
        return SUCCESS;
    }
}

三：方法三实现ApplicationContextAware
一定要在spring.xml中加上:
<bean id="SpringContextUtil " class="com.am.oa.commons.service.SpringContextUtil " singleton="true" />
当对SpringContextUtil 实例时就自动设置applicationContext,以便后来可直接用applicationContext

public class SpringContextUtil implements ApplicationContextAware {
private static ApplicationContext applicationContext;     //Spring应用上下文环境

/**
* 实现ApplicationContextAware接口的回调方法，设置上下文环境
* @param applicationContext
* @throws BeansException
*/
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    SpringContextUtil.applicationContext = applicationContext;
}

/**
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
    return applicationContext;
}

/**
* 获取对象
* @param name
* @return Object 一个以所给名字注册的bean的实例
* @throws BeansException
*/
public static Object getBean(String name) throws BeansException {
    return applicationContext.getBean(name);
}

/**
* 获取类型为requiredType的对象
* 如果bean不能被类型转换，相应的异常将会被抛出（BeanNotOfRequiredTypeException）
* @param name       bean注册名
* @param requiredType 返回对象类型
* @return Object 返回requiredType类型对象
* @throws BeansException
*/
public static Object getBean(String name, Class requiredType) throws BeansException {
    return applicationContext.getBean(name, requiredType);
}

/**
* 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
* @param name
* @return boolean
*/
public static boolean containsBean(String name) {
    return applicationContext.containsBean(name);
}

/**
* 判断以给定名字注册的bean定义是一个singleton还是一个prototype。
* 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
* @param name
* @return boolean
* @throws NoSuchBeanDefinitionException
*/
public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
    return applicationContext.isSingleton(name);
}

/**
* @param name
* @return Class 注册对象的类型
* @throws NoSuchBeanDefinitionException
*/
public static Class getType(String name) throws NoSuchBeanDefinitionException {
    return applicationContext.getType(name);
}

/**
* 如果给定的bean名字在bean定义中有别名，则返回这些别名
* @param name
* @return
* @throws NoSuchBeanDefinitionException
*/
public static String[] getAliases(String name) throws NoSuchBeanDefinitionException {
    return applicationContext.getAliases(name);
}
}

action调用：
package com.anymusic.oa.webwork;

import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;

import com.anymusic.oa.commons.service.ServiceLocator;
import com.anymusic.oa.hibernate.pojo.Role;
import com.anymusic.oa.hibernate.pojo.Users;
import com.anymusic.oa.spring.IUserService;
import com.opensymphony.webwork.ServletActionContext;
import com.opensymphony.xwork.Action;
import com.opensymphony.xwork.ActionContext;
import com.opensymphony.xwork.ModelDriven;

public class UserAction extends BaseAction implements Action,ModelDriven{

    private Users user = new Users();
//不用再加载springContext.xml文件,因为在web.xml中配置了,在程序中启动是就有了.
    UserService userService = (UserService) SpringContextUtil.getBean("userService");

    public String execute() throws Exception {
        return SUCCESS;
    }

public Object getModel() {
        return user;
    }

    public String getAllUser(){
        HttpServletRequest request = ServletActionContext.getRequest();
        List ls=userService.LoadAllObject( Users.class );
        request.setAttribute("user",ls);
        this.setUrl("/yonghu.jsp");
        return SUCCESS;
    }
}

四.通过servlet 或listener设置spring的ApplicationContext,以便后来引用.
注意分别extends ContextLoaderListener和ContextLoaderServlet .然后就可用SpringContext来getBean.
覆盖原来在web.xml中配置的listener或servlet.

public class SpringContext {
private static ApplicationContext applicationContext; //Spring应用上下文环境

*/
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
SpringContextUtil.applicationContext = applicationContext;
}

/**
* @return ApplicationContext
*/
public static ApplicationContext getApplicationContext() {
return applicationContext;
}

*/
public static Object getBean(String name) throws BeansException {
return applicationContext.getBean(name);
}

}

public class SpringContextLoaderListener extends ContextLoaderListener{ //
public void contextInitialized(ServletContextEvent event) {
  super.contextInitialized(event);
  SpringContext.setApplicationContext(
    WebApplicationContextUtils.getWebApplicationContext(event.getServletContext())
    );
}
}

public class SpringContextLoaderServlet extends ContextLoaderServlet {
private ContextLoader contextLoader;
    public void init() throws ServletException {
        this.contextLoader = createContextLoader();
        SpringContext.setApplicationContext(this.contextLoader.initWebApplicationContext(getServletContext()));
    }

}

关于@resource的注解

@Resource 注解被用来激活一个命名资源（namedresource）的依赖注入，在JavaEE应用程序中，该注解被典型地转换为绑定于JNDI context中的一个对象。Spring确实支持使用@Resource通过JNDIlookup来解析对象，默认地，拥有与@Resource注解所提供名字相匹配的“beanname（bean名字）”的Spring管理对象会被注入。在下面的例子中，Spring会向加了注解的setter方法传递bean名为“dataSource”的Spring管理对象的引用。

@Resource(name="dataSource")

 public void setDataSource(DataSource dataSource) {

   this.dataSource = dataSource;

}

直接使用@Resource注解一个域（field）同样是可能的。通过不暴露setter方法，代码愈发紧凑并且还提供了域不可修改的额外益处。正如下面将要证明的，@Resource注解甚至不需要一个显式的字符串值，在没有提供任何值的情况下，域名将被当作默认值。

@Resource

private DataSource dataSource; // inject the bean named 'dataSource'

该方式被应用到setter方法的时候，默认名是从相应的属性衍生出来，换句话说，命名为'setDataSource'的方法被用来处理名为'dataSource'的属性。

private DataSource dataSource;

@Resource

public void setDataSource(DataSource dataSource) {

   this.dataSource = dataSource;

}

当@Resource没有显式提供名字的时候，如果根据默认名字找不到对应的Spring管理对象，注入机制会回滚至类型匹配（type-match）。如果刚好只有一个Spring管理对象符合该依赖的类型，那么它会被注入。通过设置CommonAnnotationBeanPostProcessor的‘fallbackToDefaultTypeMatch’属性为“false”（默认值是“true”）可以禁用这一特性。

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor">

   <property name="fallbackToDefaultTypeMatch" value="false"/>

</bean>

正如上文所提到的，在解析标有@Resource注解的依赖时，Spring支持JNDI-lookup。如若要强制对所有使用@Resource注解的依赖进行JNDIlookup，那也只要将CommonAnnotationBeanPostProcessor的'alwaysUseJndiLookup'标识设置为true就可以了（默认值是false）。

<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor">

   <property name="alwaysUseJndiLookup" value="true"/>

</bean>

另一个选择是，激活指定为‘resource-ref-mappings’的依据全局JNDI名的查找，在@Resource注解内提供‘mappedName’属性。即使目标对象实际上是一个JNDI资源，仍然推荐引入一个Spring管理对象，这样可以提供一个间接层并且因此降低耦合程度。自Spring2.0开始添加命名空间以来，定义一个委托Spring处理JNDIlookup的bean也变得愈发简练：

<jee:jndi-lookup id="dataSource" jndi-name="java:comp/env/jdbc/petclinic"/>

这个方法的优点在于间接层带来了巨大的部署弹性。比如说，一个单独的系统测试环境应该不再需要JNDI注册。在这种情况下，在系统测试配置中可以提供如下的bean定义：

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"

          p:driverClassName="${jdbc.driverClassName}"

   p:url="${jdbc.url}"

   p:username="${jdbc.username}"

         p:password="${jdbc.password}"/>

顺便提一下，上面的例子中，实际的JDBC连接属性从一个属性文件（propertiesfile）解析而来，在这个属性文件里，关键字与提供的${占位符}互相对应，这需要注册一个名为PropertyPlaceholderConfigurer的BeanFactoryPostProcessor实现来完成。这是具体化那些属性（通常是针对特定环境的属性）常用的技术，这些属性可能比其他配置修改得更为频繁。

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">

   <property name="location" value="classpath:jdbc.properties"/>

</bean>

Srping2.5中新加入了‘context’命名空间，这个命名空间让我们能够得到更为简洁的方式来实现属性占位符（propertyplaceholder）的配置：

<context:property-placeholder location="classpath:jdbc.properties"/>

DING135DING

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
有关spring的依赖注入和@resource注解的使用

控制反转(Inversion of Control)和依赖注入(Dependency Injection)：IoC，直观地讲，就是容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，
复制链接

扫一扫