Spring Note--IOC

最新推荐文章于 2024-09-14 12:04:08 发布

Bart_G

最新推荐文章于 2024-09-14 12:04:08 发布

阅读量472

点赞数 1

分类专栏： Spring 文章标签： spring 框架

本文链接：https://blog.csdn.net/rocky_03/article/details/53456446

版权

Spring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1 什么是Spring

spring是J2EE应用程序框架，是轻量级的IoC和AOP的容器框架，主要是针对javaBean的生命周期进行管理的轻量级容器，可以单独使用，也可以和Struts框架，Hibernate,Mybatis,ibatis框架等组合使用。是著名的SSH框架之一。

2 Spring的核心之IOC

2.1 Ioc的两个概念

IOC：控制反转(inverse of control)创建对象的”控制”被”spring框架”反转了，结果等同于不在通过new来创建对象，通过spring框架来创建和销毁对象实现了程序的解耦。
DI:依赖注入(dependency injection),创建的对象依赖spring框架来注入给程序。
- 具体有关IOC的入门级概念介绍，有一篇比较好的博客推荐。在我初学时对IOC的理解有很多帮助，推荐给大家。

————————–==*参考博客传送门*==——————————-

2.2 Spring环境配置

比较好说这篇博客的所有示例程序的lib的jar包全部打包好了，下载好后解压缩并放置到Java工程目录下，并且添加到环境变量中即可。==点此下载所有JAR包==

2.3 使用IOC容器给JavaBean赋初始值

创建一个Person类：

package com.bart.bean;

public class Person {
    private String name;
    private int age;

    Person(){
        System.out.println("Person的构造函数");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void info(){
        System.out.println("person name:"+this.name+"\nage:"+this.age);
    }
}

配置bea.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     xmlns="http://www.springframework.org/schema/beans"
     xsi:schemaLocation="http://www.springframework.org/schema/beans
     http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
     default-autowire="byName"
     >
<bean id="person" class="com.bart.bean.Person">
 </bean>
</beans>

测试：

    // 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("bean.xml");
    // 2. 获得person类实例
    Person p = context.getBean("person", Person.class);
    p.info();

输出结果：

Person的构造函数
person name:null
age:0

这个例子的person name和age都没有值，按照传统的方法，我们是先创建一个对象然后使用set方法给对象赋值的，但是有了IOC后，就不用这么麻烦了，直接在Spring的XML配置文件中可以给对象赋值了，只需在上面的XML中修改一下就好了。

<bean id="person" class="com.bart.bean.Person">
    <property name="name" value="XiaoMing"/>
    <property name="age" value="20"/>
</bean>

再测试输出结果变为：

Person的构造函数
person name:XiaoMing
age:20

2.4 IOC的两种注入方式

首先创建两个接口：

package com.bart.service;

public interface InjectionService {

    public void save(String arg);
}
=================分割线=======================
package com.bart.dao;

public interface InjectionDAO {

    public void save(String arg);
}

接口的实现类：

package com.bart.dao;

import org.springframework.stereotype.Repository;

public class InjectionDAOImpl implements InjectionDAO{

    @Override
    public void save(String arg) {
        // 模拟数据库操作
        System.out.println("InjectionDAOImpl-data save :"+arg);
    }
}
=========================分割线=====================================
package com.bart.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.bart.dao.InjectionDAO;

public class InjectionServiceImpl implements InjectionService{

    InjectionDAO injectionDAO;

    //1. 构造注入方式
    public InjectionServiceImpl(InjectionDAO injectionDAO) {
        this.injectionDAO = injectionDAO;
    }   

    //2. set注入方式
    public void setInjectionDAO(InjectionDAO injectionDAO) {
        this.injectionDAO = injectionDAO;
    }

    @Override
    public void save(String arg) {
        //模拟业务操作
        System.out.println("InjectionServiceImpl-Service info :"+arg);
        injectionDAO.save(arg+":"+this.hashCode());
    }
}

bean.xml配置：

 </bean>
 <bean id="injectionDAO" class="com.bart.dao.InjectionDAOImpl">
 </bean>
 <bean id="injectionService" class="com.bart.service.InjectionServiceImpl">
    <!--  set设置注入 -->
    <property name="injectionDAO" ref="injectionDAO" />
    <!-- 构造器注入  -->
    <constructor-arg name="injectionDAO" ref="injectionDAO"/>
 </bean>

测试：

    // 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("bean.xml");
    // 2. 获得person类实例
    Person p = context.getBean("person", Person.class);
    p.info();

结果：

InjectionServiceImpl-Service info :这是一条数据
InjectionDAOImpl-data save :这是一条数据--类的HashCode：581536050

==总结：两种方法都可以创建Bean，但是构造器的方法比较耗费资源，故常用的还是set设置方法。==

2.5 Bean的生命周期

Ioc容器非还提供了对Bean的生命周期的管理方法；初始化和销毁都可以交给Ioc容器来完成

2.5.1.在bean.xml的配置文件中配置

标签体重配置init-method=”start” destroy-method=”stop” ，并在类中实现start设stop方法

测试类：

package com.bart.live;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class LifeCycle implements InitializingBean,DisposableBean{

    /* 自定义方法，并在bean.xml中配置init-method和destroy-method标签 */
    public void start(){
        System.out.println("自定义LifeCycle初始化方法");    
    }
    public void stop(){
        System.out.println("自定义LifeCycle结束方法");
    }
}

配置bean.xml文件：

<!-- 初始化方法测试 init-method="start" destroy-method="stop"-->
 <bean id="lifeCycle" class="com.bart.live.LifeCycle" 
    init-method="start" destroy-method="stop">
 </bean>

测试：

// 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("bean.xml");
    // 2. 获得person类实例
    context.getBean("lifeCycle");
    context.start();
    context.destroy();

结果：

自定义LifeCycle初始化方法
自定义LifeCycle结束方法

2.5.2.实现接口org.springframework.beans.foctory.InitializingBean

实现InitializingBean接口，覆盖afterPropertiesSet方法。系统会自动查找afterPropertiesSet方法，执行其中的初始化操作实现org.springframework.beans.foctory.DisposableBean接口，覆盖destory()方法。

测试类：

package com.bart.live;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class LifeCycle implements InitializingBean,DisposableBean {

    /*
     * 重写DisposableBean接口的的销毁方法
     * */
    @Override
    public void destroy() throws Exception {
        System.out.println("重写DisposableBean的destory()方法");     
    }
    /*
     * 重写InitializingBean接口的的初始化方法
     * */
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("重写InitializingBean的afterPropertiesSet()方法");

    }
}

如果是实现接口的方法，则xml文件中只需要配置lifeCycle类的<bean />标签就行了

<bean id="lifeCycle" class="com.bart.live.LifeCycle" >
</bean>

测试：

// 1. 读取bean.xml
context = new ClassPathXmlApplicationContext("bean.xml");
// 2. 获得person类实例
LifeCycle lifeCycle = (LifeCycle) context.getBean("lifeCycle"); context.start();
context.destroy();

结果：

重写InitializingBean的afterPropertiesSet()方法
重写DisposableBean的destory()方法

2.5.3. 配置全局初始化

在<beans ...>根标签中配置两个default方法

 <beans 
    default-init-method="DefaultInit" 
    default-destroy-method="DefaultDestroy" 
    >

测试：

// 1. 读取bean.xml
context = new ClassPathXmlApplicationContext("bean.xml");
// 2. 获得person类实例
LifeCycle lifeCycle = (LifeCycle) context.getBean("lifeCycle");
context.start();
context.destroy();

结果：

DefaultInit--全局初始化方法
DefaultDestroy--全局结束方法

2.6 Bean 的 Resources资源载入

2.6.1 针对资源文件的统一接口

UrlResource：URL对应的资源，根据一个URL地址即可
ClassPathResource:获取类路径下的资源文件
FileSystemResource:获取文件系统里面的资源
ServletContextResource：ServletContext封装的资源问ServletContext环境下资源
InputStreamResource:针对输入流封装的资源
ByteArrayResource:针对字节数组封装的资源

2.6.2 资源加载实现：

实现ApplacationContextAware接口，并重写setApplicationContext()方法接受ApplicationContext对象
context.getResource()方法返回Resource对象，传入的路径有以下几种：

Resource resource = context.getResource("路径");
classpath路径是src目录:classpath:ErrorLog.txt
file表示文件完整路径:file:D:\\Java works\\SpringDemo1\\Recorder.txt
ftp:C:\\config.txt
http:http://blog.csdn.net/rocky_03

测试的java类：

// 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("bean.xml");
    System.out.println("testAware: "+context.getBean("beanAware").hashCode());
        //调用加载资源 的方法
    BeanAware beanAware = (BeanAware) context.getBean("beanAware");
    beanAware.resource();

输出结果：

BeanName:beanAware
ApplicationContext:581536050
testAware: 581536050
Recorder.txt
9410

2.7 Spring的注解

从Spring3.0开始，spring JavaConfig项目提供了注解特性

例如：

@Configuration,@Bean,@Import,@DependsOn
@Component是一个通用注解，可用于任何bean
@Repository,@Service,@Controller
- @Repository：通常用于注解DAO类，即持久层
- @Service：通常用于注解Service类，即服务层
- @Controller：通常用于控制层（MVC）

scope：范围

singleton:单例，指一个Bean容器中只存在一份
prototype：每次请求(每次使用)创建新的实例，destroy方法不生效
request：每次http请求创建一个实例且仅当在当前request内有效
session：同上，每次http请求创建，当前session内有效
global session：基于portlet的web中有效(portlet定义了global session)，如果是在web中，同session

2.7.1 注解和注解范围scope

注解类：

/**
  *注解测试
  * */
package com.bart.annotation;

import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

/* 表示设置注入的id */
@Component("beanAnnotation")
@Scope("prototype")
public class BeanAnnotation {

    public void say(){
        System.out.println("BeanAnnotation:这是say()方法");
    }

    public void getHashCode(){
        System.out.println("BeanAnnotation:getHashCode--"+this.hashCode());
    }
}

beanAnnotation.xml文件配置

 <!-- 配置注解要扫描的包名  -->  
    <context:component-scan base-package="com.bart.annotation"></context:component-scan>

测试：

context = new ClassPathXmlApplicationContext("beanAnnotation.xml");
        BeanAnnotation beanAnnotation = (BeanAnnotation) context.getBean("beanAnnotation");
        beanAnnotation.say();
        beanAnnotation.getHashCode();
        beanAnnotation = (BeanAnnotation) context.getBean("beanAnnotation");
        beanAnnotation.getHashCode();

结果：

BeanAnnotation:这是say()方法
BeanAnnotation:getHashCode--1457062995
BeanAnnotation:getHashCode--1101730224

==注意：==

输出结果的hashcode值不一样，是因为在配置直接时候@Scope("prototype")里面的prototype表示每次请求(每次使用)创建新的实例，destroy方法不生效。

2.7.2 测试注解(Injection)注入

==用到的注解有==：

@Service表示通常用于注解Service层，即服务层
@Autowired注解：表示把依赖的对象添加给注解的对象或方法
@Respository通常用于注解DAO层表示该类被spring框架作为一个bean处理

创建两个接口：

package com.bart.dao;

public interface InjectionDAO {

    public void save(String arg);
}
==============分割线=================
package com.bart.service;

public interface InjectionService {

    public void save(String arg);
}

接口的实现类:

package com.bart.dao;

import org.springframework.stereotype.Repository;

/*  测试注解的使用
 * @Respository通常用于注解DAO层
 * 表示该类被spring框架作为一个bean处理
 *  */
@Repository
public class InjectionDAOImpl implements InjectionDAO{

    @Override
    public void save(String arg) {
        // 模拟数据库操作
        System.out.println("InjectionDAOImpl-data save :"+arg);
    }
}
=========================分割线======================================
package com.bart.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.bart.dao.InjectionDAO;

/* 测试注解 的使用
 * @Service表示通常用于注解Service层，即服务层
 * @Autowired注解：表示把依赖的对象添加给注解的对象或方法
 * */
@Service()
public class InjectionServiceImpl implements InjectionService{

    @Autowired
    InjectionDAO injectionDAO;

    //构造注入方式
    @Autowired
    public InjectionServiceImpl(InjectionDAO injectionDAO) {
        this.injectionDAO = injectionDAO;
    }   

    //set注入方式
    @Autowired
    public void setInjectionDAO(InjectionDAO injectionDAO) {
        this.injectionDAO = injectionDAO;
    }

    @Override
    public void save(String arg) {
        //模拟业务操作
        System.out.println("InjectionServiceImpl-Service info :"+arg);
        injectionDAO.save(arg+"--类的HashCode："+this.hashCode());
    }

}

配置beanAnnotation.xml:

<context:component-scan base-package="com.bart.service"></context:component-scan>
    <context:component-scan base-package="com.bart.dao"></context:component-scan>

测试:

// 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("beanAnnotation.xml");
    // 2. 获得类实例
    InjectionService in = (InjectionServiceImpl) context
            .getBean("injectionServiceImpl");
    in.save("这是一条数据");

输出结果：

InjectionServiceImpl-Service info :这是一条数据
InjectionDAOImpl-data save :这是一条数据--类的HashCode：1132909700

2.7.3 注解自动解析接口的多实现

==用到的注解有==：

@Component：是一个通用注解，可用于任何bean
@Order(x):x是1…n的数字，表示实现接口的类的顺序
@Autowired：
@Qulifier(“Bean类名”) 用于缩小范围，指定那个bean对象传入@Autowired注解修饰的接口

创建接口：

package com.bart.multibean;

import org.springframework.stereotype.Component;

@Component
public interface BeanInterface {
    public void say();
}

接口的两个实现类和一个测试类：

package com.bart.multibean;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(1)//按顺序插入
public class BeanOne implements BeanInterface{
    public void say(){
        System.out.println("this is BeanOne say...");
    }
}
==================分割线========================
package com.bart.multibean;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Component
@Order(2)
public class BeanTwo implements BeanInterface{

    public void say(){
        System.out.println("this is BeanTwo say...");
    }
}
==================分割线========================
/*  
 * @Order貌似只对List有效，Map依然顺序不改变
 * */
package com.bart.multibean;

import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

@Component
public class BeanInvoke {

    @Autowired
    private List<BeanInterface>list;
    @Autowired
    private Map<String, BeanInterface>map;

    /*  @Qulifier("Bean类名")  
     * 用于缩小范围，指定那个bean对象传入@Autowired注解修饰的接口
     * */
    @Autowired
    @Qualifier("beanOne")
    private BeanInterface beanInterface;

    public void getList(){
        if(list!=null&&list.size()!=0){
            for(BeanInterface bi:list){
                System.out.println("list--"+bi.getClass().getName());
            }
        }else {
            System.out.println("list is empty");
        }
    }

    public void getMap(){
        if(map!=null&&map.size()!=0){
            for(Map.Entry<String, BeanInterface> entry:map.entrySet()){
                System.out.println("map--"+entry.getValue().getClass().getName());
            }
        }else {
            System.out.println("map is empty");
        }
        System.out.println("测试@Qualifier注解");
        System.out.println(beanInterface.getClass().getName());
    }
}

配置beanAnnotation.xml文件：

 <context:component-scan base-package="com.bart.multibean"></context:component-scan>

测试：

// 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("beanAnnotation.xml");
    // 2. 获得类实例
    BeanInterface bi = (BeanInterface) context
            .getBean("beanOne");
    BeanInterface bi2 = (BeanInterface) context
                .getBean("beanTwo");
    bi.say();
    bi2.say();
    BeanInvoke beanInvoke = (BeanInvoke) context
                .getBean("beanInvoke");
    beanInvoke.getList();
    beanInvoke.getMap();

输出结果：

this is BeanOne say...
this is BeanTwo say...
list--com.bart.multibean.BeanOne
list--com.bart.multibean.BeanTwo
map--com.bart.multibean.BeanOne
map--com.bart.multibean.BeanTwo
测试@Qualifier注解
com.bart.multibean.BeanOne

==总结==：

通过测试可得出结论，当使用@Autowired注解List或者Map集合时候，Spring容器会自动装配接口的实现类到List或者Map中

2.7.4 @Bean注解的使用

前面配置注入的注解不外乎两个，一个是@Component另外一个是@Autowired,这里介绍另外一种@Bean的注解

@Bean标示一个用于配置和初始化一个由SpringIoC容器管理的新对象的方法，类似于XML配置文件的
可以在Spring的@Component注解的类中使用@Bean注解任何方法(仅仅是可以)
通常使用的是@Configuration,功能==类似==于@Component
- Component 用于将所标注的类加载到 Spring 环境中，需要搭配 component-scan 使用
- Configuration 是 Spring 3.X 后提供的注解，用于取代 XML 来配置 Spring。

==实例：==

使用@Bean注解和@Configuration实现注入

接口：

package com.bart.annotation;

public interface Store<T> {
    public void say();
}

java类：

package com.bart.annotation;

public class StringStore implements Store<String>{

    public void init(){
        System.out.println("StringStore:init()");
    }

    public void destory(){
        System.out.println("StringStore:destory()");
    }

    @Override
    public void say() {
        System.out.println("StringStore:say()");
    }
}
===========================分割线==========================================
package com.bart.annotation;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class StoreConfig {
    /* 
     * @Bean配合@Configuration注解类似于在xml中配置<bean id="name" class="xxx.xxx.xx"/>
     * 只需要在类前配置@Configuration和类中方法配置@Bean即可实现依赖注入的管理
     * */
    //@Bean
    @Bean(name="store",initMethod="init",destroyMethod="destory")
    public Store stringStore(){
        return new StringStore();
    }
}

配置beanAnnotion.xml文件

 <!-- 配置注解要扫描的包名  -->  
    <context:component-scan base-package="com.bart.annotation"></context:component-scan>

测试：

// 1. 读取bean.xml
context = new ClassPathXmlApplicationContext("beanAnnotation.xml");
Store store = (Store) context.getBean("store");
store.say();
System.out.println(store.getClass().getName());

输出结果：

StringStore:init()
StringStore:say()
com.bart.annotation.StringStore
StringStore:destory()

2.7.5 注解加载资源文件

前面说过配置xml文件的方式加载资源文件，这里介绍一种注解的方式加载资源文件

创建一个xxx.properties
创建一个config.xml文件，并配置标签<context:property-placeholder location="classpath:/xxx.properties"/>
在类名称前使用@Configuration和@ImportResource("classpath:config.xml")导入资源配置的xml文件路径

==用到的注解==：

@ImportResource(“classpath:config.xml”)：导入资源配置的config.xml文件路径
@Configuration:是一个通用注解，可用于任何bean
@Value

==实例：==

在连接数据库的时候我们需要输入用户名，密码，端口号，URL地址等，每次在代码中配置显得很不方便，有了Spring容器之后，每次只需改变配置文件的propertis便可以快速的改变数据库的连接。

配置jdbc.properties：

#Created by JInto - www.guh-software.de
#Fri Aug 15 10:00:46 CST 2014
jdbc.password=root
jdbc.url=jdbc\:mysql\://127.0.0.1.8\:3306/myjdbc
jdbc.username=root

配置config.xml：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd" >

    <!-- 资源文件加载路径-->    
    <context:property-placeholder location="classpath:/jdbc.properties"/>

</beans>

配置beanAnnotation.xml

<!-- 配置注解要扫描的包名  -->  
    <context:component-scan base-package="com.bart.annotation"></context:component-scan>

数据库管理类

package com.bart.annotation;

public class MyDriverManager {

    public MyDriverManager(){

    }
    public MyDriverManager(String url, String userName, String password) {
    /* 模拟业务逻辑 */    
        System.out.println("url : " + url);
        System.out.println("userName: " + userName);
        System.out.println("password: " + password);
    }
}
==========================分割线================================
package com.bart.annotation;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

@Configuration
@ImportResource("classpath:config.xml")//导入资源配置的xml文件路径
public class StoreConfig {

    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.password}")
    private String password;
    @Value("${jdbc.username}")
    private String username;

    @Bean
    public MyDriverManager myDriverManager(){
        return new MyDriverManager(url, username, password);
    }
}

测试：

// 1. 读取bean.xml
       context = new ClassPathXmlApplicationContext("beanAnnotation.xml");
       MyDriverManager mdm = (MyDriverManager) context.getBean("myDriverManager");
       System.out.println(mdm.getClass().getName());

输出结果：

url : jdbc:mysql://127.0.0.1.8:3306/myjdbc
userName: root
password: root
com.bart.annotation.MyDriverManager

2.7.6 注解的泛型自动装配

创建一个带泛型的接口，当有多个实现类的时候，通过注解可以自动的识别泛型接口来注入相关的实现类

用到的注解：

@Autowired
@Bean
@Configuration

==实例：==

创建一个带泛型的Animal的接口：

package com.bart.generic;

public interface Animal<T> {

    public void say();

}

两个实现类Cat和Dog

package com.bart.generic;

public class Dog implements Animal<Integer>{

    @Override
    public void say() {
        System.out.println("this is dog`s say()...");
    }

}
==================分割线==============================
package com.bart.generic;

public class Cat implements Animal<String>{

    @Override
    public void say() {
        System.out.println("this is Cat`s say()...");
    }

}
==================分割线==============================
/*
 * 测试泛型自动装配
 * */
package com.bart.generic;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AnimalConfig {

    @Autowired
    private Animal<String> a1;
    @Autowired
    private Animal<Integer> a2;

    @Bean
    public Cat cat(){
        System.out.println("@Bean 创建Cat");
        return new Cat();
    }

    @Bean
    public Dog dog(){
        System.out.println("@Bean 创建Dog");
        return new Dog();
    }

    @Bean(name="animal")    
    public Animal catAnimal(){
        System.out.println("@Bean 创建Cat返回为Animal");
        System.out.println(a1.getClass().getName());
        System.out.println(a2.getClass().getName());
        return new Cat();
    }
}

beanAnnotation.xml配置：

<context:component-scan base-package="com.bart.generic"></context:component-scan>

测试：

// 1. 读取bean.xml
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(
                "beanAnnotation.xml");

输出结果：

@Bean 创建Cat
@Bean 创建Dog
@Bean 创建Cat返回为Animal
com.bart.generic.Cat
com.bart.generic.Dog

2.7.7 JSR的介绍

Spring支持使用JSR-250的@Resource注解的变量或者setter方法，这时一种在JavaEE 5 和
6 的通用模式，Spring管理的对象也支持这种模式

注解类型	注入方式	提供者
@Resource	默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入	注解是由J2EE的JSR-250标准提供
@Autowired	默认是按照类型装配注入的，如果想按照名称来转配注入，则需要结合@Qualifier一起使用	由spring提供

==用到的注解：==

@Repository
@Service
@Resource
@Inject
@Named
@PostConstruct：初始化
@PreDestroy：销毁

==实例：==
JsrDao和JsrService类：

package com.bart.jsr;

import org.springframework.stereotype.Repository;

@Repository
public class JsrDao {

        public void say(String str){
            System.out.println("JsrDao`s say:"+str);
        }
}
======================分割线==========================
/*
 * 1. 测试@Service配合@Resource使用
 * 2. 测试@Named配合@Inject
 * */
package com.bart.jsr;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import javax.inject.Inject;
import javax.inject.Named;

@Service
//@Named
public class JsrService {

    @Resource
//  @Inject
    private JsrDao jsrDao;

    @Resource
    @Inject
    //@Named可以标示参数前,效果和@Qualifier("类名")一样，确定唯一的实例类@Named("jsrDao")
    public void setJsrDao(JsrDao jsrDao){
        this.jsrDao=jsrDao;
    }

    //初始化注解
    @PostConstruct
    public void init(){
        System.out.println("JsrService`s @PostConstruct注解 init...");
    }
    //销毁注解
    @PreDestroy
    public void destory(){
        System.out.println("JsrService`s @PostConstruct注解 destory...");
    }

    public void say(){
        jsrDao.say("jsr`s say method");
    }
}

测试：

// 1. 读取bean.xml
    context = new ClassPathXmlApplicationContext("beanAnnotation.xml");
    JsrService jsrService = (JsrService) context.getBean("jsrService");     
    jsrService.say();
    context.destroy();

输出结果：

JsrService`s @PostConstruct注解 init...
JsrDao`s say:jsr`s say method
JsrService`s @PostConstruct注解 destory...

==总结：==
1. 测试@Service配合@Resource使用
2. 测试@Named配合@Inject

测试@Service和@Resource时候可以先注释掉@Named和@Inject，反之亦然，最终结果一样。

在初学的过程中遇到过很多不懂的地方自己也是查阅资料和阅读各位大神们的博客才搞明白的。
也这篇博客记录了学习Spring的一些基础的知识。大部分是简单的小例子。便于初学者理解。
博客的代码都是经过本人测试正确运行的。由于本人才学疏浅，难免会有不足或者遗漏的地方，还望读者见谅。

Bart_G

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录