Spring02

通天云计算

于 2019-12-26 23:09:42 发布

阅读量488

点赞数

分类专栏：大数据

本文链接：https://blog.csdn.net/WYJ____/article/details/103714791

版权

大数据专栏收录该内容

45 篇文章 1 订阅

订阅专栏

1.setter注入

2.构造器注入

3.属性占位符的使用

4.注册案例

5.DI注解

6.IoC注解

7.javaconfig

一、setter注入

Setter注入:最常用的注入方法,需要在xml配置文件中进行手动的配置.

要求: 对象中的每个属性必须要有setter 方法

如何配置: 需要为对象中的每个属性配置一个"property"标签:<property name="" />

其中name属性的值为对象中属性的名字.如何给属性注入值时,需要先确定该属性的类型

对象中的属性分为以下三种类型,不同的类型使用不同的注入方式：

1):简单数据类型(八大基本类型,String,BigDecimal,Date等). 使用value.

2):引用数据类型. 使用ref.

3):集合数据类型. 使用集合的元素.

示例：准备数据(之前添加的依赖)

1.注入简单数据类型

public class Employee {
    private String name;
    private Integer age;
    private Date birthday;
    private BigDecimal salary;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public void setSalary(BigDecimal salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                ", salary=" + salary +
                '}';
    }
}

    <!--简单数据类型-->
    <!--setter方式注入：本质是在执行对象中的set方法
        Spring容器在注入值时，隐含着类型转换-->
    <bean id="employee" class="com.xj._01_setter.Employee">
        <property name="name" value="xj"/>
        <property name="age" value="20"/>
        <property name="birthday" value="1999/09/09"/>
        <property name="salary" value="9999"/>
    </bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {

    @Autowired
    private Employee employee;

    @Test
    public void testEmployee(){
        System.out.println(employee);
    }

}

2.注入引用数据类型

public class Dog {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                '}';
    }
}

public class Person {
    private Dog dog;

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    @Override
    public String toString() {
        return "Person{" +
                "dog=" + dog +
                '}';
    }
}

    <!--引用数据类型-->
    <bean id="dog" class="com.xj._01_setter.Dog">
        <property name="name" value="旺财"/>
    </bean>
    <!--ref:引入当前容器中的bean-->
    <bean id="person" class="com.xj._01_setter.Person">
        <property name="dog" ref="dog"></property>
    </bean>

    @Autowired
    private Person person;

    @Test
    public void testPerson(){
        System.out.println(person);
    }

3.集合数据类型

public class CollectioBean {
    private Set<String> set;
    private List<String> list;
    private String[] array;
    private Map<String,String> map;
    private Properties prop;

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setArray(String[] array) {
        this.array = array;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProp(Properties prop) {
        this.prop = prop;
    }

    @Override
    public String toString() {
        return "CollectioBean{" +
                "set=" + set +
                ", list=" + list +
                ", array=" + Arrays.toString(array) +
                ", map=" + map +
                ", prop=" + prop +
                '}';
    }
}

    <!--集合数据类型，使用property标签，在双标签中使用各个集合对应的标签-->
    <bean id="collection" class="com.xj._01_setter.CollectioBean">
        <property name="set">
            <set>
                <value>set1</value>
                <value>set2</value>
                <value>set3</value>
            </set>
        </property>

        <property name="list">
            <list>
                <value>list1</value>
                <value>list2</value>
                <value>list3</value>
            </list>
        </property>

        <property name="array">
            <array>
                <value>array1</value>
                <value>array2</value>
                <value>array3</value>
            </array>

        </property>

        <property name="map">
            <map>
                <entry key="k1" value="v1"></entry>
                <entry key="k2" value="v2"></entry>
                <entry key="k3" value="v3"></entry>
            </map>
        </property>

        <property name="prop">
            <props>
                <prop key="p1">v1</prop>
                <prop key="p2">v2</prop>
            </props>
        </property>
    </bean>

    @Autowired
    private CollectioBean collectioBean;

    @Test
    public void testCollection(){
        System.out.println(collectioBean);
    }

小结:

1.使用setter方法注入,要求对象中必须有属性对应的setter方法,在xml中每一个属性需要配置"property标签"

2.property标签的name属性的值为属性的名字

3.当对象中属性的类型为简单类型时,使用value属性注入.(会自动进行类型转换)

4.当对象中属性的类型为引用类型时,使用ref属性注入.ref的值为Spring容器中已经存在的对象的名字.

5.当对象中属性的类型为集合类型时,需要将property属性展开,对于不同类型的结合,是用其对应的标签进行注入.

6.setter方式注入是最常用的注入方式,必须掌握

二、构造器注入

构造器注入:利用构造函数为对象中的属性注入值,需要在xml配置文件中进行手动的配置.

要求: 对象中必须存在有参数的构造函数.xml中手动配置了哪些属性需要注入值,对象中必须存在对应的属性为参数的构造函数.

如何配置: 需要为对象中的每个属性配置一个"constructor-arg"标签:<constructor-arg name="" /> 其中name属性的值构造函数中形参的名字.如何给属性注入值时,需要先确定该属性的类型(与setter注入方式类似)

对象中的属性分为以下三种类型,不同的类型使用不同的注入方式：

1):简单数据类型(八大基本类型,String,BigDecimal,Date等). 使用value.

2):复合数据类型. 使用ref.

3):集合数据类型. 使用集合的元素.

public class Employee {
    private String name;
    private Integer age;
    private Date birthday;
    private BigDecimal salary;

    public Employee(){}
    public Employee(String name, Integer age, Date birthday, BigDecimal salary) {
        this.name = name;
        this.age = age;
        this.birthday = birthday;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                ", salary=" + salary +
                '}';
    }
}

    <bean id="employee" class="com.xj._02_constructor.Employee">
        <constructor-arg name="name" value="jack"/>
        <constructor-arg name="age" value="18"/>
        <constructor-arg name="birthday" value="2019/01/01"/>
        <constructor-arg name="salary" value="1000.00"/>
    </bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {

    @Autowired
    private Employee employee;

    @Test
    public void testEmployee(){
        System.out.println(employee);
    }

}

小结:

1.构造器的注入方式与setter注入方式类似,配置文件只是把setter注入方式中的"property"标签替换为"constructor-arg"标签.

2.使用构造器注入方式,在xml配置文件中配置了要为哪些属性注入值,在对象中必须存在对应的所有属性的构造函数.

3.构造器的注入方式在开发中使用,方式只需要了解.不要求掌握.

三、属性占位符的使用

1、添加依赖

         <!--德鲁伊连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
    </dependencies>

2、在Spring中配置德鲁伊连接池时,需要为连接数据库的连接四要素注入值.由于连接数据库四要素都为字符串类型,因此为其四个属性设置值,只需要使用value属性为四要素注入值.value的值可以为写死的字符串.

但是在开发中,通常把连接字符串写在properties文件中.

3、将properties引入到Spring的配置文件中,然后再通过属性占位符读取properties文件中额配置信息.

引入properties配置文件的配置如下: <context:property-placeholder location="classpath:db.properties" />

其中在添加上述配置之前需要引入新的命名空间 location:默认从classpath路径中需要文件,最好加"classpath"前缀.

    <!--引入属性配置文件
       location:从什么位置加载属性配置文件
       默认情况下是从classes路径开始寻找
   -->
    <context:property-placeholder location="classpath:db.properties"/>

    <!--配置德鲁伊的连接池-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${driverClassName}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
    </bean>

4、编写测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {

    @Autowired
    private DataSource dataSource;

    @Test
    public void testDataSource() throws Exception {
        System.out.println(dataSource.getConnection());
    }

}

运行测试类

报错。连接数据库的时候发生错误，用户名或密码错误。'Administrator'@'localhost'是当前电脑的登录用户，在Spring配置文件中，获取向当前登录用户的键也是username，跟系统环境变量冲突了。

解决方法一：添加一个标签system-properties-mode（默认使用），设置为NEVER，不使用系统环境变量

运行测试类

解决方法二（推荐）：添加前缀

运行测试类

小结:

1.只有在添加了命名空间之后才能使用命名空间下的标签

2.使用"context:property-placeholder"引入properties属性文件,配置"location"属性.

3.使用"${}"获取properties属性文件的值.

四、注册案例

1、添加依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.xj</groupId>
    <artifactId>Spring02</artifactId>
    <version>1.0.0</version>

    <properties>
        <!--定义全局变量，变量名为：project.spring.version-->
        <project.spring.version>5.0.0.RELEASE</project.spring.version>
    </properties>


    <dependencies>
        <!--Spring-core-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-beans-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-expression-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-context-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${project.spring.version}</version>
        </dependency>
        <!--Spring-aop-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${project.spring.version}</version>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        

        <!--德鲁伊连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.10</version>
        </dependency>
        <!--mysql连接驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.38</version>
        </dependency>
    </dependencies>


    <build>
        <!--从哪个地方加载配置文件-->
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
            </resource>
        </resources>
    </build>

</project>

2、数据库

3、db.properties配置文件

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring
jdbc.username=root
jdbc.password=root

4、实体类

package com.xj.bean;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public class User {
    private Integer id;
    private String username;
    private String password;
    private String tel;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getTel() {
        return tel;
    }

    public void setTel(String tel) {
        this.tel = tel;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", tel='" + tel + '\'' +
                '}';
    }
}

5、dao

package com.xj.dao;

import com.xj.bean.User;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public interface IUserDao {
    void save(User user);
}

package com.xj.dao.impl;

import com.xj.bean.User;
import com.xj.dao.IUserDao;

import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public class UserDaoImpl implements IUserDao {

    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void save(User user) {
        try {
            Connection conn = dataSource.getConnection();
            String sql = "insert into user (username,password,tel) values(?,?,?)";
            PreparedStatement ps = conn.prepareStatement(sql);
            ps.setString(1,user.getUsername());
            ps.setString(2,user.getPassword());
            ps.setString(3,user.getTel());
            ps.executeUpdate();
            conn.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

6、service

package com.xj.service;

import com.xj.bean.User;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public interface IUserService {
    void register(User user);
}

package com.xj.service.impl;

import com.xj.bean.User;
import com.xj.dao.IUserDao;
import com.xj.service.IUserService;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public class UserServiceImpl implements IUserService{

    private IUserDao dao;

    public void setDao(IUserDao dao) {
        this.dao = dao;
    }

    public void register(User user) {
        dao.save(user);
    }
}

7、controller

package com.xj.controller;

import com.xj.bean.User;
import com.xj.service.IUserService;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public class UserController {
    private IUserService service;

    public void setService(IUserService service) {
        this.service = service;
    }

    public void service(){
        //获取请求参数
        String username = "rose";
        String password = "123";
        String tel = "11122223333";

        User user = new User();
        user.setUsername(username);
        user.setPassword(password);
        user.setTel(tel);

        //执行操作
        service.register(user);
    }
}

8、applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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:db.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <bean id="userDao" class="com.xj.dao.impl.UserDaoImpl">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <bean id="userService" class="com.xj.service.impl.UserServiceImpl">
        <property name="dao" ref="userDao" />
    </bean>

    <bean id="userController" class="com.xj.controller.UserController">
        <property name="service" ref="userService"/>
    </bean>
</beans>

9、测试类

package com.xj;

import com.xj.controller.UserController;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class App {

    @Autowired
    private ApplicationContext context;

    @Test
    public void testRegister(){
        UserController controller = context.getBean(UserController.class);
        controller.service();
    }

}

10、结果

五、DI注解

在Spring中使用注解来完成DI操作,我们称之为注解自动装配,存在两种用法：

一:使用Spring框架自身提供的注解:@Autowired

二:使用JavaEE规范提供的注解:@Resource 功能完全一样

1.使用Spring框架自身提供的注解：Autowired

Autowired和Qualifier标签：

1.通过@Autowired标签可以让Spring自动的把对象需要的属性从Spring容器中找出来，并注入(设置)给该属性。

2.第三方程序：Spring3.0之前，需要手动配置@Autowired注解解析程序； <context:annotation-config />

在Spring3.0开始，Spring就会自动的加入针对@Autowired标签的解析程序。

3.@Autowired标签贴在字段或者setter方法上。

4.@Autowired可以同时为一个属性注入多个对象。 public void setXxx(OtherBean1 other1,OtherBean2 other2) {}

5.使用@Autowired标签可以注入Spring内置的重要对象，比如BeanFactory，ApplicationContext。

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration public class SpringTest {

@Autowired

private ApplicationContext ctx;

}

6.默认情况下@Autowired标签必须要能找到对应的对象，否则报错。不过，可使用required=false来避免该问题：

@Autowired(required=false)

7.@Autowired找bean的方式：

1）、首先按照依赖对象的类型找，如果没有找到,默认会报错;如果找到一个匹配的对象,直接注入;

2）、如果在Spring上下文中找到多个匹配(2个或者2个以上)的类型，再按照名字去找，如果没有匹配则报错；

3）、可以通过使用@Qualifier("otherBean")标签来规定依赖对象按照bean的id+类型去找；

public class Cat {
}

public class Person {

    //从容器中寻找字段对应的类型的对象，自动的去注入值
    @Autowired
    private Cat cat;

    public void setCatAndDog(Cat cat){
        this.cat=cat;
    }

    @Override
    public String toString() {
        return "Person{" +
                "cat=" + cat +
                '}';
    }
}

    <bean id="cat" class="com.xj._04_autowired.Cat"></bean>
    <bean id="person" class="com.xj._04_autowired.Person"></bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {

    @Autowired
    private Person person;

    @Test
    public void testPerson(){
        System.out.println(person);
    }
}

2.使用JavaEE规范提供的注解:Resource

@Resource标签:

1,@Resource标签是JavaEE规范的标签;

2,@Resource标签也可以作用于字段或者setter方法;

3,也可以使用@Resource标签注入一些spring内置的重要对象,比如BeanFactory.ApplicationContext;

4,@Resource必须要求有匹配的对象;

5,Spring容器自动加载了@Resource的注解解析器

6,@Resource标签找bean的方式:

1),首先按照名字去找,如果找到,就使用setter或者字段注入;

2),如果按照名字找不到,再按照类型去找,但如果找到多个类型匹配类型,报错;

3),可以直接使用name属性指定bean的名称;但是,如果指定的name,就只能按照name去找,如果找不到,就不会再按照类型去找;

public class Pig {
}

public class Employee {

    @Resource
    private Pig pig;

    @Override
    public String toString() {
        return "Employee{" +
                "pig=" + pig +
                '}';
    }
}

    <bean id="pig" class="com.xj._05_resource.Pig"></bean>
    <bean id="employee" class="com.xj._05_resource.Employee"></bean>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {

    @Autowired
    private Employee employee;

    @Test
    public void testEmployee(){
        System.out.println(employee);
    }
}

@Autowired和@Resource注解的区别

1.@Autowired可以同时为两个属性注入值,@Resource一次只能为一个属性注入值

2.@Resource要求容器中必须有匹配的对象;@Autowired默认要求容器中必须有匹配对象,但是可以通过"required=false"修改其默认设置.

3.@Autowired首先首先通过类型寻找匹配对象,当有多个相同类型时再按照名字找; @Resource注解首先按照名字寻找匹配对象,没有找到时在按照类型来找.

小结:

1.@Autowired和@Resource注解的最多用法是贴在类中的属性中,表示从容器中找到需要的属性并自动给属性注入值.

2.两个注解都可以贴在setter方法上.

3.两个注解都可以注入容器对象.

4.两个注解都是使用"<context:annotation-config>"为注解的解析器.

5.@Autowired和@setter方法的区别:

@setter注解:lombok包中的注解,只是为属性添加一个setter方法

@Autowired注解:spring框架的注解,表示将容器中的对象自动的注入被贴的属性中.

六、IoC注解

使用标签简化IoC:

1.使用标签来完成IoC,就必须有IoC注解的解析器

使用context:component-scan来扫描spring需要管理的bean

base-package就告诉spring,去哪些包及其子包里去扫描bean,如果有多个包需要被扫描;只需要用逗号隔开多个包即可

<context:component-scan base-package="com.xj.xxx" />

2.标注Bean的注解：@Component 默认情况,直接使用类的名字(首字母小写作为bean的名字) 如果要修改bean的名称;直接使用value属性来重新定义bean的名称 @Component("otherbean") public class OtherBean {}

3.使用@Component的限制: 对于没有源代码的类(框架内部的预定义类),只能用XML配置;比如DataSource就只能使用XML方式来做IOC.

4.bean组件版型标签 bean组件版型：

@Repository用于标注数据访问组件，即DAO组件。

@Service用于标注业务层组件、

@Controller用于标注控制层组件（如struts中的action）、

@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

5.指定bean的作用域：@Scope("prototype")

6.初始化和销毁方法

@PostConstruct public void init() { 相当于<bean init-method="init" />

@PreDestroy public void destory() { 相当于<bean destroy-method="destory" />

7.选用xml还是注解：

1),Annotation:使用方便,XML文件很小,但是,依赖关系又重新回到了代码当中;

2),XML:使用稍微复杂,但是,代码很干净,代码不会很任何框架产生关系;XML安全; 两种方式都必须掌握;

@Component("some")
public class SomeBean {
}

        <!--IoC注解扫描
            组件扫描
            base-package：从配置的包中，扫描所有标注了IoC注解的类型，自动的创建该类的对象
            并且放入到Spring容器（包含子包）
        -->
        <context:component-scan base-package="com.xj._06_component"/>

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration
public class App {

    @Autowired
    private ApplicationContext context;

    @Test
    public void test(){
        SomeBean someBean = context.getBean("some",SomeBean.class);
        System.out.println(someBean);
    }
}

小结:

1.使用IoC的注解,必须配置IoC的注解解析器"<context:component-scan base-package="com.ujiuye.spring.xxx" />"

2.不同的组件贴不同的版型标签,当无法确定具体属于那一层的组件时,贴@Component注解

3.@Scope注解控制对象的作用域

4.@PostConstruct表示对象的初始化方法,在对象被创建之后执行,@PreDestroy表示对象的销毁方法,在对象销毁之前执行.

七、javaconfig

@configuration:表示当前类是一个配置类

@Bean:容器中创建出一个对象

@PropertySource:寻找属性配置文件

@ImportResource:寻找xml配置文件

@import注解:引入另位外一个配置文件

@ComponentScan:扫描组件

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

</beans>

package com.xj._07_javaconfig;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
public class Config2 {
}

package com.xj._07_javaconfig;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;

import javax.sql.DataSource;

/**
 * Created by Administrator on 2019/12/26 0026.
 */
@Configuration
@PropertySource("classpath:db.properties")
@ImportResource()
@Import(Config2.class)
@ComponentScan("com.xj")
public class Config {

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

    @Bean
    public DataSource dataSource(){
        DruidDataSource data = new DruidDataSource();
        data.setDriverClassName(driverClassName);
        data.setUrl(url);
        data.setUsername(username);
        data.setPassword(password);
        return data;
    }

}

package com.xj._07_javaconfig;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.sql.DataSource;

/**
 * Created by Administrator on 2019/12/26 0026.
 */

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = Config.class)
public class App {

    @Autowired
    private DataSource dataSource;

    //旧的测试
    @Test
    public void tetConfig() throws Exception{

        //获取容器
        AnnotationConfigApplicationContext context
                = new AnnotationConfigApplicationContext(Config.class);
        DataSource dataSource = context.getBean(DataSource.class);
        System.out.println(dataSource.getConnection());

    }

    //Spring测试
    @Test
    public void testDatasoure() throws Exception {
        System.out.println(dataSource.getConnection());
    }
}

通天云计算

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring02

1.setter注入2.构造器注入3.属性占位符的使用4.注册案例5.DI注解6.IoC注解7.javaconfig一、setter注入Setter注入:最常用的注入方法,需要在xml配置文件中进行手动的配置.要求: 对象中的每个属性必须要有setter 方法如何配置: 需要为对象中的每个属性配置一个"property"标签:<property ...
复制链接

扫一扫