Spring注解

今天来说一下Spring注解

注解是个好东西，但好东西我们也是看见过，整理过，理解过，用过才知道好。不求我们每个都记住，但求保有印象，在需要的时候能提取出来再查找相关资料，平时工作就不会显得那么被动了。

1.@Configuration注解

1.1@Configuration + <context>

该类等价与XML中配置beans，相当于Ioc容器，它的某个方法头上如果注册了@Bean，就会作为这个Spring容器中的Bean，与xml中配置的bean意思一样。

@Configuration注解的类必需使用<context:component-scanbase-package=”XXX”/>扫描.如下：

例：

程序结构图：

（1）首先建立Perons.java，person实体类

package com.zk.Bean;
 
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.stereotype.Component;
 
@Configuration
public class Person {
    public Person() {
        System.out.println("Person初始化");
    }
     
}

（2）其次在建立MainApp.java

package com.zk.Main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
import com.zk.Bean.Person;
 
public class MainApp {
    public static void main(String[]args)
    {
        ApplicationContext context = new AnnotationConfigApplicationContext(Person.class);
    }
}

（3）ApplicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 
<context:component-scan base-package="com.zk.Bean" />
</beans>

　运行结果：

1.2、@Configuration启动容器+@Bean注册Bean，@Bean下管理bean的生命周期

（1）首先建立TestBean.java，实体类

package com.zk.Bean;
 
import org.springframework.beans.factory.annotation.Value;
 
public class TestBean {
    @Value("zk")
    private String name;
    private String url;
    private String password;
     
     
    @Override
    public String toString() {
        return "TestBean [name=" + name + ", url=" + url + ", password="
                + password + "]";
    }
     
    public void sayHello(){
        System.out.println(name+":sayHello");
    }
     
    public void start(){
        System.out.println(name+":start");
    }
     
    public void cleanup(){
        System.out.println(name+":cleanup");
    }
}

（2）创建TestConfigure.java

package com.zk.Bean;
 
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;
 
 
@Configuration
public class TestConfigure {
 
    public TestConfigure(){
        System.out.println("TestConfiguration...");
    }
     
     
    @Bean
    @Scope("prototype")
    TestBean testBean(){
        return new TestBean();
    }
}

　（3）创建ApplicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 
<context:component-scan base-package="com.zk.Bean" />
</beans>

　　（4）创建TestMain.java

package com.zk.Bean;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
 
public class TestMain {
    public static void main(String[]args)
    {
        // @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
        ApplicationContext context=new AnnotationConfigApplicationContext(TestConfigure.class);
         
         
        //获取bean
        TestBean tb=(TestBean) context.getBean("testBean");
        tb.sayHello();
    }
}

运行结果如下：

2.@Value注解

在程序中使用@Value的注解是为了给变量赋值，如上面的注解：

1 2	`@Value("zk")` `private` `String name;`

　　使用

// @Configuration注解的spring容器加载方式，用AnnotationConfigApplicationContext替换ClassPathXmlApplicationContext
ApplicationContext context=new AnnotationConfigApplicationContext(TestConfigure.class);
//获取bean
TestBean tb=(TestBean) context.getBean("testBean");
tb.sayHello();

　　调用getBean()方法可以获取到name的值。

3. @Controller, @Service, @Repository,@Component

目前4种注解意思是一样，并没有什么区别，区别只是名字不同。使用方法：

（1）创建com.zk.component，创建TestObject.java

package com.zk.component;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
 
import org.springframework.stereotype.Component;
 
 
@Component
public class TestObject {
    @PostConstruct 
    public void contructbefore(){
        System.out.println("初始化之前的操作");
    }
     
    @PreDestroy
    public void contructAfter(){
        System.out.println("初始化之后的操作");
    }
}

（2）创建com.zk.controller，并创建UserController.java

package com.zk.controller;
 
import org.springframework.stereotype.Controller;
 
 
@Controller
public class UserController {
    public void execute(){
        System.out.println("UserController execute...");
    }
}

（3）创建com.zk.Service，并创建UserService.java

package com.zk.service;
 
import org.springframework.stereotype.Service;
 
 
@Service
public class UserService {
     
    public void add(){
        System.out.println("UserService add..");
    }
}

（4）创建com.zk.Repository，并创建UserRepository.java和UserRepositoryImpl.java

package com.zk.UserRepository;
 
 
public interface UserRepository {
    public void save();
}

package com.zk.UserRepository;
 
import org.springframework.stereotype.Repository;
 
@Repository("userRepository")
public class UserRepositoryImpl implements UserRepository{
 
    @Override
    public void save() {
        // TODO Auto-generated method stub
        System.out.println("UserRepository save");
    }
     
}

（5）最后，实现MainAPP实现类：

MainAPP.java

package Main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.zk.UserRepository.UserRepository;
import com.zk.component.TestObject;
import com.zk.controller.UserController;
import com.zk.service.UserService;
 
public class MainAPP {
    public static void main(String[]args)
    {
        ApplicationContext ac=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        TestObject to=(TestObject) ac.getBean("testObject");
        System.out.println(to.toString());
         
        UserService us=(UserService) ac.getBean("userService");
        us.add();
         
        UserRepository ur=(UserRepository)ac.getBean("userRepository");
        ur.save();
         
        UserController uc=(UserController)ac.getBean("userController");
        uc.execute();
    }
}

ApplicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 
  
<context:component-scan base-package="com.zk.controller" />
<context:component-scan base-package="com.zk.component" />
<context:component-scan base-package="com.zk.UserRepository" />
<context:component-scan base-package="com.zk.service" />
</beans>

执行Main后结果如下:

4. @PostConstruct 和 @PreDestory

实现初始化和销毁bean之前进行的操作，只能有一个方法可以用此注释进行注释，方法不能有参数，返回值必需是void,方法需要是非静态的。

TestObject.java

package com.zk.component;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
 
import org.springframework.stereotype.Component;
 
 
@Component
public class TestObject {
    @PostConstruct 
    public void contructbefore(){
        System.out.println("初始化之前的操作");
    }
     
    @PreDestroy
    public void contructAfter(){
        System.out.println("初始化之后的操作");
    }
}

MainAPP.java

package Main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; 
import com.zk.component.TestObject;
public class MainAPP {
    public static void main(String[]args)
    {
        AbstractApplicationContext ac=new ClassPathXmlApplicationContext("ApplicationContext.xml");
        TestObject to=(TestObject) ac.getBean("testObject");
        System.out.println(to.toString());      
        ((AbstractApplicationContext) ac).close();
    }
}

applicationContext.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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd
    http://www.springframework.org/schema/tx 
    http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    http://www.springframework.org/schema/aop 
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
 
  
 
 <context:component-scan base-package="com.zk.component" />
</beans>

执行结果如下：

@PostConstruct：在构造方法和init方法（如果有的话）之间得到调用，且只会执行一次。

@PreDestory：注解的方法在destory()方法调用后得到执行。

引深一点，Spring 容器中的 Bean 是有生命周期的，Spring 允许在 Bean 在初始化完成后以及 Bean 销毁前执行特定的操作，常用的设定方式有以下三种：

1.通过实现 InitializingBean/DisposableBean 接口来定制初始化之后/销毁之前的操作方法；

2.通过 <bean> 元素的 init-method/destroy-method属性指定初始化之后 /销毁之前调用的操作方法；

3.在指定方法上加上@PostConstruct 或@PreDestroy注解来制定该方法是在初始化之后还是销毁之前调用

但他们之前并不等价。即使3个方法都用上了，也有先后顺序.

Constructor > @PostConstruct >InitializingBean > init-method

5. @Autowired,@Qualifier

@Autowired是用在JavaBean中的注解，默认通过byType形式查找Bean，如果发现多个Bean,则使用byName形式查找Bean，用来给指定的字段或方法注入所需的外部资源。

可以手动使用@Qualifier注解给需要通过byName形式查找的Bean进行赋值，例如

@Autowired
@Qualifier(“pean”)
public Fruit fruit;　

UserDao.java

package com.zk.dao;
 
public interface UserDao {
    public void sayHello();
}

UserDaoImpl.java

package com.zk.dao;
 
import org.springframework.stereotype.Repository;
 
@Repository("UserDao")
public class UserDaoImpl implements UserDao{
     
    public void sayHello(){
        System.out.println("userdao hello");
    }
}

UserService.java

package com.zk.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.zk.dao.UserDao;
 
@Service
public class UserService {
    @Autowired
    private UserDao userdao;
     
    public void sayHello(){
    userdao.sayHello();
    }
}

Main.App

package Main;
 
import org.springframework.context.ApplicationContext;
 
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.zk.service.UserService;
 
public class MainApp {
    public static void main(String[]args)
    {
        ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService object = (UserService) ctx.getBean("userService");
        object.sayHello();
    }
}

执行MainApp

6. @Primary

（1）首先创建fruit接口，并建立继承fruit接口的两个子类Apple.java，Pear.java，在Pear.java中添加@Primary，将Pear类设为优先。

fruit.java

package com.zk.mybean;
 
import org.springframework.stereotype.Component;
 
 
public interface fruit {
    public void sayHello();
}

Apple.java

package com.zk.mybean;
 
import org.springframework.stereotype.Component;
 
 
 
@Component
public class Apple implements fruit{
    public void sayHello(){
        System.out.println("Apple Hello");
    }
}

Pear.java

package com.zk.mybean;
 
import org.springframework.context.annotation.Primary;
import org.springframework.stereotype.Component;
 
 
@Component
@Primary
public class Pear implements fruit{
    public void sayHello(){
        System.out.println("Pear Hello");
    }
}

（2）创建fruitService.java

package com.zk.myservice;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.zk.mybean.fruit;
@Service
public class fruitService {
     
    @Autowired
    public fruit fruit;
     
    public void getfruit(){
        fruit.sayHello();
    }
     
}

（3）最后，实现MainAPP.java和ApplicationContext.xml

package Main;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.zk.mybean.fruit;
import com.zk.myservice.fruitService;
 
public class MainAPP {
    public static void main(String[]args)
    {
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        fruitService fs=(fruitService) ac.getBean(fruitService.class);
        fs.getfruit();
    }
}