• SpringBoot：第一章JavaConfig、@ImportResource、@PropertyResource等总结（动力）

    在做spring、springmvc项目的时候需要写大量的配置文件，比较麻烦，在大型的项目，对象较多，写的配置文件较多，容易出错，还需要继承第三方的框架，需要写配置文件，比如说写一个mybatis，需要在spring的配置文件中写mybatis集成的对象，做每个对象的配置才能用。Spring也发现了这个问题，spring想改变这种格局，少点写配置，直接去做项目功能，所以打造除了springboot这个框架，解决了spring、sporingmvc的痛点，几乎很少写配置文件，他可以把大多数的框架和第三方资源都已经写好了配置，直接在我们项目中来使用。

    用springboot可以直接实现spring、springmvc那些功能，而不用在写配置文件了，极大的 提高了开发效率，减轻了我们使用配置文件的难度，springboot相当于一个更加快速的spring+springmvc

     

     

     

    目录：

    （1）通过配置文件创建对象：

    （2）使用JavaConfig配置容器：配置Bean

    （3）@ImportResource的使用：读入xml配置文件

     （4）@PropertyResource读入配置文件

     

    pom.xml:引入依赖

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0</modelVersion>
    6.  
    7.     <groupId>com.bjpowernode</groupId>
    8.     <artifactId>001-springboot-pre</artifactId>
    9.     <version>1.0.0</version>
    10.  
    11.     <dependencies>
    12.         <!--spring依赖-->
    13.         <dependency>
    14.             <groupId>org.springframework</groupId>
    15.             <artifactId>spring-context</artifactId>
    16.             <version>5.3.1</version>
    17.         </dependency>
    18.  
    19.         <dependency>
    20.             <groupId>junit</groupId>
    21.             <artifactId>junit</artifactId>
    22.             <version>4.12</version>
    23.         </dependency>
    24.     </dependencies>
    25.  
    26.     <build>
    27.         <plugins>
    28.             <!--编译插件-->
    29.             <plugin>
    30.                 <artifactId>maven-compiler-plugin</artifactId>
    31.                 <!--插件的版本-->
    32.                 <version>3.5.1</version>
    33.                 <!--编译的级别-->
    34.                 <configuration>
    35.                     <source>1.8</source>
    36.                     <target>1.8</target>
    37.                     <!--编码格式-->
    38.                     <encoding>UTF-8</encoding>
    39.                 </configuration>
    40.             </plugin>
    41.         </plugins>
    42.     </build>
    43. </project>

    （1）通过配置文件创建对象： 

    创建spring配置文件

    beans.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    6.     <!--声明bean对象,并初始化-->
    7.     <bean id="myStudent" class="com.bjpowernode.vo.Student">
    8.         <property name="name" value="李四"/>
    9.         <property name="age" value="20"/>
    10.         <property name="sex" value="女"/>
    11.     </bean>
    12. </beans>

    Student类：

    1. package com.bjpowernode.vo;
    2.  
    3. public class Student {
    4.     private String name;
    5.     private Integer age;
    6.     private String sex;
    7.  
    8.     public String getName() {
    9.         return name;
    10.     }
    11.  
    12.     public void setName(String name) {
    13.         this.name = name;
    14.     }
    15.  
    16.     public Integer getAge() {
    17.         return age;
    18.     }
    19.  
    20.     public void setAge(Integer age) {
    21.         this.age = age;
    22.     }
    23.  
    24.     public String getSex() {
    25.         return sex;
    26.     }
    27.  
    28.     public void setSex(String sex) {
    29.         this.sex = sex;
    30.     }
    31.  
    32.     @Override
    33.     public String toString() {
    34.         return "Student{" +
    35.                 "name='" + name + '\'' +
    36.                 ", age=" + age +
    37.                 ", sex='" + sex + '\'' +
    38.                 '}';
    39.     }
    40. }

    测试类：

    MyTest：

    1. package com.bjpowernode;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import org.junit.Test;
    5. import org.springframework.context.ApplicationContext;
    6. import org.springframework.context.support.ClassPathXmlApplicationContext;
    7.  
    8. public class MyTest {
    9.     /*
    10.     * 使用xml作为容器配置文件
    11.     * */
    12.     @Test
    13.     public void test01(){
    14.         String config="beans.xml";
    15.         ApplicationContext ctx=new ClassPathXmlApplicationContext(config);//获取工厂
    16.         Student student = (Student) ctx.getBean("myStudent");
    17.         System.out.println("容器中的对象："+student);
    18.     }
    19. }

     

    （2）使用JavaConfig配置容器 

    创建配置Bean Java类：SpringConfig：

    1. package com.bjpowernode.config;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6.  
    7. @Configuration //声明注解，配置Bean，代替spring配置文件，就是用来配置容器的
    8. public class SpringConfig {
    9.     /*
    10.     * 创建方法，方法的返回值是对象，在方法的上面加入@Bean
    11.     * 方法的返回值对象就注入到容器中
    12.     *
    13.     * @Bean:把对象注入到spring容器中，作用相当于<bean>标签
    14.     *  说明：@Bean，不指定对象的名称，默认是方法名是id
    15.     * */
    16.     @Bean
    17.     public Student createStudent(){
    18.         Student s1=new Student();
    19.         s1.setName("张三");
    20.         s1.setAge(26);
    21.         s1.setSex("男");
    22.         return s1;
    23.     }
    24.  
    25.     /*
    26.     * 指定对象在容器中的名称（指定<bean>的id属性）
    27.     * @Bean的Name属性，指定对象的名称（id）
    28.     * */
    29.     @Bean(name = "lisiStudent")
    30.     public Student makeStudent(){
    31.         Student s2=new Student();
    32.         s2.setName("李四");
    33.         s2.setAge(20);
    34.         s2.setSex("男");
    35.         return s2;
    36.     }
    37. }

    MyTest:

    1. package com.bjpowernode;
    2.  
    3. import com.bjpowernode.config.SpringConfig;
    4. import com.bjpowernode.vo.Student;
    5. import org.junit.Test;
    6. import org.springframework.context.ApplicationContext;
    7. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    8. import org.springframework.context.support.ClassPathXmlApplicationContext;
    9.  
    10. public class MyTest {
    11.     /*
    12.     * 使用xml作为容器配置文件
    13.     * */
    14.     @Test
    15.     public void test01(){
    16.         String config="beans.xml";
    17.         ApplicationContext ctx=new ClassPathXmlApplicationContext(config);//获取工厂
    18.         Student student = (Student) ctx.getBean("myStudent");
    19.         System.out.println("容器中的对象："+student);
    20.     }
    21.     /*
    22.     * 不使用配置文件，使用JavaConfig
    23.     * */
    24.     @Test
    25.     public void test02(){
    26.         ApplicationContext ctx=new AnnotationConfigApplicationContext(SpringConfig.class);//获得工厂
    27.         Student student = (Student) ctx.getBean("createStudent");//方法名字作为默认的id
    28.         System.out.println("使用JavaConfig创建bean对象："+student);
    29.     }
    30.  
    31.     //给对象取名字：@Bean(name = "lisiStudent")
    32.     @Test
    33.     public void test03(){
    34.         ApplicationContext ctx=new AnnotationConfigApplicationContext(SpringConfig.class);//获得工厂
    35.         Student student = (Student) ctx.getBean("lisiStudent");//方法名字作为默认的id
    36.         System.out.println("使用JavaConfig创建bean对象："+student);
    37.     }
    38. }

    test02:

    test03: 

     （3）@ImportResource的使用：读入xml配置文件

     

     Cat类：通过applicationContext.xml配置

    1. package com.bjpowernode.vo;
    2.  
    3. public class Cat {
    4.     private String cardId;
    5.     private String name;
    6.     private Integer age;
    7.  
    8.     public String getCardId() {
    9.         return cardId;
    10.     }
    11.  
    12.     public void setCardId(String cardId) {
    13.         this.cardId = cardId;
    14.     }
    15.  
    16.     public String getName() {
    17.         return name;
    18.     }
    19.  
    20.     public void setName(String name) {
    21.         this.name = name;
    22.     }
    23.  
    24.     public Integer getAge() {
    25.         return age;
    26.     }
    27.  
    28.     public void setAge(Integer age) {
    29.         this.age = age;
    30.     }
    31.  
    32.     @Override
    33.     public String toString() {
    34.         return "Cat{" +
    35.                 "cardId='" + cardId + '\'' +
    36.                 ", name='" + name + '\'' +
    37.                 ", age=" + age +
    38.                 '}';
    39.     }
    40. }

    创建一个需要导入的配置文件applicationContext.xml：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    5.  
    6.     <bean id="myCat" class="com.bjpowernode.vo.Cat">
    7.         <property name="name" value="tom猫"/>
    8.         <property name="age" value="2"/>
    9.         <property name="cardId" value="uw521651451"/>
    10.     </bean>
    11. </beans>

    配置Bean中导入：配置文件：

    SpringConfig：

    1. package com.bjpowernode.config;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import org.springframework.context.annotation.Bean;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.springframework.context.annotation.ImportResource;
    7.  
    8. @Configuration //声明注解，配置Bean，代替spring配置文件，就是用来配置容器的
    9. @ImportResource(value = "classpath:applicationContext.xml") //通过注解引入applicationContext配置文件
    10. //@ImportResource(value = {"classpath:applicationContext.xml","classpath:beans.xml"}) //通过{} 可以导入多个配置文件
    11. public class SpringConfig {
    12.     /*
    13.     * 创建方法，方法的返回值是对象，在方法的上面加入@Bean
    14.     * 方法的返回值对象就注入到容器中
    15.     *
    16.     * @Bean:把对象注入到spring容器中，作用相当于<bean>标签
    17.     *  说明：@Bean，不指定对象的名称，默认是方法名是id
    18.     * */
    19.     @Bean
    20.     public Student createStudent(){
    21.         Student s1=new Student();
    22.         s1.setName("张三");
    23.         s1.setAge(26);
    24.         s1.setSex("男");
    25.         return s1;
    26.     }
    27.  
    28.     /*
    29.     * 指定对象在容器中的名称（指定<bean>的id属性）
    30.     * @Bean的Name属性，指定对象的名称（id）
    31.     * */
    32.     @Bean(name = "lisiStudent")
    33.     public Student makeStudent(){
    34.         Student s2=new Student();
    35.         s2.setName("李四");
    36.         s2.setAge(20);
    37.         s2.setSex("男");
    38.         return s2;
    39.     }
    40. }

    测试类测试MyTest：

    1.  //测试注解@ImportResource 导入xml配置文件
    2.     @Test
    3.     public void test04(){
    4.         ApplicationContext ctx=new AnnotationConfigApplicationContext(SpringConfig.class);
    5.         Cat cat = (Cat) ctx.getBean("myCat");
    6.         System.out.println("cat==="+cat);
    7.     }

    输出结果证明applicationContest导入成功 

     （4）@PropertyResource读入配置文件

     

     

    Tiger：属性值来自属性配置文件

    1. package com.bjpowernode.vo;
    2.  
    3. import org.springframework.beans.factory.annotation.Value;
    4. import org.springframework.stereotype.Component;
    5.  
    6. @Component("tiger") //注解创建Tiger对象，就不用写<bean>标签创建了
    7. public class Tiger {
    8.     @Value("${tiger.name}")
    9.     private String name;
    10.     @Value("${tiger.age}")
    11.     private Integer age;
    12.  
    13.     @Override
    14.     public String   toString() {
    15.         return "Tiger{" +
    16.                 "name='" + name + '\'' +
    17.                 ", age=" + age +
    18.                 '}';
    19.     }
    20. }

     创建config.properties配置文件：

    tiger.name=东北虎
tiger.age=3

     在配置Bean中加入注解：SpringConfig：@PropertySource @ComponentScan

    1. package com.bjpowernode.config;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import org.springframework.context.annotation.*;
    5.  
    6. @Configuration //声明注解，配置Bean，代替spring配置文件，就是用来配置容器的
    7.  
    8. @ImportResource(value = "classpath:applicationContext.xml") //通过注解引入applicationContext配置文件
    9. //@ImportResource(value = {"classpath:applicationContext.xml","classpath:beans.xml"}) //通过{} 可以导入多个配置文件
    10.  
    11. @PropertySource(value = "classpath:config.properties") //注解读取到properties配置文件
    12.  
    13. @ComponentScan(basePackages = "com.bjpowernode.vo") //老虎对象使用注解创建的，告诉容器去哪找这个对象上面的注解，使用包扫描
    14. public class SpringConfig {
    15.     /*
    16.     * 创建方法，方法的返回值是对象，在方法的上面加入@Bean
    17.     * 方法的返回值对象就注入到容器中
    18.     *
    19.     * @Bean:把对象注入到spring容器中，作用相当于<bean>标签
    20.     *  说明：@Bean，不指定对象的名称，默认是方法名是id
    21.     * */
    22.     @Bean
    23.     public Student createStudent(){
    24.         Student s1=new Student();
    25.         s1.setName("张三");
    26.         s1.setAge(26);
    27.         s1.setSex("男");
    28.         return s1;
    29.     }
    30.  
    31.     /*
    32.     * 指定对象在容器中的名称（指定<bean>的id属性）
    33.     * @Bean的Name属性，指定对象的名称（id）
    34.     * */
    35.     @Bean(name = "lisiStudent")
    36.     public Student makeStudent(){
    37.         Student s2=new Student();
    38.         s2.setName("李四");
    39.         s2.setAge(20);
    40.         s2.setSex("男");
    41.         return s2;
    42.     }
    43. }

    测试类：MyTest：

    1. //测试@PropertySource注解，引入配置文件的使用  使用@Component创建对象
    2.     @Test
    3.     public void test05(){
    4.         ApplicationContext ctx=new AnnotationConfigApplicationContext(SpringConfig.class);
    5.         Tiger tiger = (Tiger) ctx.getBean("tiger");
    6.         System.out.println("tiger==="+tiger);
    7.     }

     

     说明：@Configuration就相当于xml,在类上面写的注解就相当于在原来的Spring配置文件中写的：

     

  • 相关阅读:
    网络编程套接字
    腾讯云2核4G服务器5M带宽 218元一年 优惠价格明细表
    【调研】在线考试系统调研
    C++ Qt开发：TreeWidget 树形选择组件
    大数据平台下的数据治理
    我认为除了HelloWorld之外，Python的三大数据转换实例可以作为开始学习Python的入门语言。
    MySQL 是怎样运行的：单表访问方法及基于成本的优化
    百度智能云千帆AppBuilder升级！开放多源模型接入，思考模型再次加速！
    系统集成|第十六章(笔记)
    总结 Thread 类的基本用法
  • 原文地址：https://blog.csdn.net/dengfengling999/article/details/125504953