栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spring:高级注解

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spring:高级注解

 

 

 

 

配置Bean就是为了取代配置文件,不用写ApplicationContext.xml了,所以Configuration不会用

@Bean注解是在配置Bean:@Configuration中用来创建对象的

 

 

Spring针对复杂对象用FactoryBean来创建

Scope=“”控制对象创建次数

 

 

 

 

pom.xml:



  4.0.0

  com.itheima
  spring11
  1.0-SNAPSHOT
  
    
      
        org.apache.maven.plugins
        maven-compiler-plugin
        
          6
          6
        
      
    
  

  
    
    
      org.springframework
      spring-tx
      5.1.14.RELEASE
    
    
    
      junit
      junit
      4.11
      test
    
    
    
      org.springframework
      spring-context
      5.1.14.RELEASE
    

    

    
      org.slf4j
      slf4j-api
      1.7.25
    
    
      org.slf4j
      jcl-over-slf4j
      1.7.25
    
    
      ch.qos.logback
      logback-classic
      1.2.3
    
    
      ch.qos.logback
      logback-core
      1.2.3
    
    
      org.logback-extensions
      logback-ext-spring
      0.1.4
    

    
    
      org.springframework
      spring-jdbc
      5.1.14.RELEASE
    
    
    
      org.mybatis
      mybatis-spring
      2.0.2
    
    
    
      com.alibaba
      druid
      1.1.18
    




    
    
      mysql
      mysql-connector-java
      5.1.48
    
    
    
      org.mybatis
      mybatis
      3.4.6
    


    
    
      org.springframework
      spring-aop
      5.1.14.RELEASE
    

    
      org.aspectj
      aspectjrt
      1.8.8
    

    
      org.aspectj
      aspectjweaver
      1.8.3
    
    
      org.testng
      testng
      RELEASE
      compile
    
  


日志文件:logback.xml 



    
    
        
            
            %d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} -%msg%n
        
    

    
        
    

 User:

package com.baizhiedu.bean;

public class User {
}

ConnectionFactoryBean

package com.baizhiedu.bean;

import org.springframework.beans.factory.FactoryBean;

import java.sql.Connection;
import java.sql.DriverManager;

public class ConnectionFactoryBean implements FactoryBean {


    @Override
    public Connection getObject() throws Exception {
        Class.forName("com.mysql.jdbc.Driver");
        Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/myBatis?useSSL=false","root","123456");
        return conn;
    }

    @Override
    public Class getObjectType() {
        return Connection.class;//返回复杂对象的class对象
    }

    @Override
    public boolean isSingleton() {
        return false;//控制创建次数,每次都创建新的
    }
}

 

AppConfig:

package com.baizhiedu;

import com.baizhiedu.bean.ConnectionFactoryBean;
import com.baizhiedu.bean.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

import java.sql.Connection;
import java.sql.Driver;
import java.sql.DriverManager;
import java.sql.SQLException;

@Configuration //@Configuration注解,代表它是一个配置Bean,代替applicationContext.xml
public class AppConfig {

    //简单对象
    //通过Bean注解创建User对象 user代表原来配置文件的id值 User代表创建对象类型
    //方法名字作为默认的id值 如果想要改变可以在@Bean("u") u作为id值
    @Bean("u")
    @Scope("prototype")//控制对象创建次数,每一次都让spring创建新的对象 prototype创建多次 singleton创建一次
    public User user(){
        return new User();
    }

    //复杂对象
    
    @Bean
    public Connection conn(){
        Connection conn=null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/myBatis?useSSL=false","root","123456");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;

    }

    //FactoryBean跟@Bean集成
    @Bean
    public Connection conn1(){
        Connection conn = null;//通过方法调用获得复杂对象
        try {
            ConnectionFactoryBean FactoryBean=new ConnectionFactoryBean();
            conn = FactoryBean.getObject();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return conn;
    }

}

UserDAO:

package com.baizhiedu.injection;

public interface UserDAO {
    public void save();
}

UserDAOImpl:

package com.baizhiedu.injection;

public class UserDAOImpl implements UserDAO {
    @Override
    public void save() {
        System.out.println("UserDAOImpl.save");
    }
}

UserService:

package com.baizhiedu.injection;

public interface UserService {
    public void register();
}

UserServiceImpl:

package com.baizhiedu.injection;




public class UserServiceImpl implements UserService {
    private UserDAO userDAO;

    public UserDAO getUserDAO() {
        return userDAO;
    }

    public void setUserDAO(UserDAO userDAO) {
        this.userDAO = userDAO;
    }

    @Override
    public void register() {
        userDAO.save();
    }
}

AppConfig1:

package com.baizhiedu;

import com.baizhiedu.bean.Customer;
import com.baizhiedu.injection.UserDAO;
import com.baizhiedu.injection.UserDAOImpl;
import com.baizhiedu.injection.UserService;
import com.baizhiedu.injection.UserServiceImpl;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration //注解配置Bean
@PropertySource("classpath:/init.properties")//注解读取配置文件,来解下面给JDK类型注入时候的耦合
public class AppConfig1 {

    @Value("${id}")  //@Value注解为id属性赋值
    private Integer id;
    @Value("${name}")
    private String name;

    //自定义类型注入
    @Bean
    public UserDAO userDAO(){
        return new UserDAOImpl();
    }

    

    //第二种注入写法不用传一个参数
    @Bean  //通过给UserService方法传递一个参数,再进行setUserDAO(userDAO)的注入赋值
    public UserService userService(){
        UserServiceImpl userService=new UserServiceImpl();
        userService.setUserDAO(userDAO());//这里调用userDAO()方法
        return userService;
    }

    // 简单对象,JDK类型注入
    @Bean
    public Customer customer(){
        Customer customer=new Customer();
//        customer.setId(1);
//        customer.setName("xiaohei");
        customer.setId(id);
        customer.setName(name);
        return customer;
    }
}

init.properties:

id=2
name=suns

TestAnnotation:

package com.baizhiedu;

import com.baizhiedu.bean.Customer;
import com.baizhiedu.bean.User;
import com.baizhiedu.injection.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.sql.Connection;

public class TestAnnotation {
    //用于测试:配置Bean
    @Test
    public void test1(){
        //ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);//可以直接指定那个配置Bean的class
        ApplicationContext ctx=new AnnotationConfigApplicationContext("com.baizhiedu");//工厂扫描配置com.baizhiedu这个包,查找具有@Configuration注解类型
    }

    //用于测试:@Bean注解 创建简单对象
    @Test
    public void test2(){
        //ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);//可以直接指定那个配置Bean的class
        ApplicationContext ctx=new AnnotationConfigApplicationContext("com.baizhiedu");
        User user=(User)ctx.getBean("u");
        System.out.println(user);
    }
    //用于测试:@Bean注解 创建复杂对象
    @Test
    public void test3(){
        //ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);//可以直接指定那个配置Bean的class
        ApplicationContext ctx=new AnnotationConfigApplicationContext("com.baizhiedu");
        Connection conn=(Connection)ctx.getBean("conn");
        System.out.println("conn:"+conn);
    }

    //用于测试:@Bean注解 创建复杂对象 FactoryBean创建复杂对象和@Bean集成
    @Test
    public void test4(){
        //ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);//可以直接指定那个配置Bean的class
        ApplicationContext ctx=new AnnotationConfigApplicationContext("com.baizhiedu");
        Connection conn1=(Connection)ctx.getBean("conn1");
        System.out.println("conn1:"+conn1);
    }

    //用于测试:测试User对象的创建次数
    @Test
    public void test5(){
        //ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig.class);//可以直接指定那个配置Bean的class
        ApplicationContext ctx=new AnnotationConfigApplicationContext("com.baizhiedu");
        User user1=(User)ctx.getBean("u");
        User user2=(User)ctx.getBean("u");
        System.out.println("user1="+user1);
        System.out.println("user2="+user2);
    }

    //用于测试:@Bean注解:自定义类型注入
    @Test
    public void test6(){
        ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig1.class);//可以直接指定那个配置Bean的class
        UserService userService=(UserService)ctx.getBean("userService");
        userService.register();
    }

    //用于测试:@Bean注解:JDK类型注入
    @Test
    public void test7(){
        ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig1.class);//可以直接指定那个配置Bean的class
        Customer customer=(Customer)ctx.getBean("customer");
        System.out.println("customer="+customer.getId());
        System.out.println("customer="+customer.getName());
    }
}

 test2:

 test3:

test4:

 

 test5:注解使用的创建对个对象,所以对象不一样

 test6:

t est7:

 

设置注解扫描:注解

注解排除

注解扫描:

User1:

 

package com.baizhiedu.scan;

import org.springframework.stereotype.Component;

@Component
public class User1 {
}

User2:

package com.baizhiedu.scan;

import org.springframework.stereotype.Service;

@Service
public class User2 {
}

AppConfig2:

package com.baizhiedu;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Service;

@Configuration //配置Bean注解
//为了扫描曾经讲过的基础注解,使其生效,扫描com.baizhiedu.scan包下的所有注解
@ComponentScan(basePackages = "com.baizhiedu.scan",
               excludeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Service.class}),
                                 @ComponentScan.Filter(type = FilterType.ASPECTJ,pattern = "*..User1")})//excludeFilters ={}注解排除排除@Service注解
public class AppConfig2 {
}

 

TestAnnotation2:

package com.baizhiedu;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TestAnnotation2 {
    //用于测试:@    componentScan 扫描基础注解的使用
    @Test
    public void test1(){
        ApplicationContext ctx=new AnnotationConfigApplicationContext(AppConfig2.class);
        String[] beanDefinitionNames=ctx.getBeanDefinitionNames();//获取所有对象的id
        for (String beanDefinitionName:beanDefinitionNames){
            System.out.println("beanDefinitionName="+beanDefinitionName);
        }
    }
}

test1:当没有写排除注解是,输出基础注解创建的对象:

当AppConfig2中写上排除注解后:

 

 

注解包含:

 

AppConfig:注释类排除注解,使用包含把@Service注解的对象包含进来

package com.baizhiedu;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Service;

@Configuration //配置Bean注解
//为了扫描曾经讲过的基础注解,使其生效,扫描com.baizhiedu.scan包下的所有注解



@ComponentScan(basePackages = "com.baizhiedu.scan",useDefaultFilters = false,
               includeFilters = {@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Service.class})})
public class AppConfig2 {
}

 test1:

 

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/936002.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号