Resumo do aprendizado do Spring (quatro): Bean de montagem baseado em XML (2)

Um, injetar valores nulos e símbolos especiais

1. Injete um valor nulo

       (1) Crie a classe de entidade User, forneça os atributos privados nome, idade e endereço, e forneça seu método set e toString ().

public class User {
    private String name;
    private Integer age;
    private String address;

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

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

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                '}';
    }
   
}

       (2) Configure o objeto Usuário em bean.xml, injete o nome e a idade e defina o endereço como nulo.

<!--  向属性注入null值  -->
    <bean id="user" class="com.yht.example1.entity.User">
        <property name="name" value="刘备"></property>
        <property name="age" value="23"></property>
        <property name="address">
            <null></null>
        </property>
    </bean>

       (3) Execute o teste de unidade.

    @Test
    public void testNull(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        User user = (User) context.getBean("user");
        System.out.println(user);
    }

       Os resultados da execução são os seguintes:

       Nota: null e "" não são iguais. Se o valor de endereço for definido como "" , o resultado da execução será o seguinte:

    <bean id="user" class="com.yht.example1.entity.User">
        <property name="name" value="刘备"></property>
        <property name="age" value="23"></property>
        <property name="address" value=""></property>
    </bean>

 

2. Injetar símbolos especiais

       Existem duas maneiras de injetar símbolos especiais: uma é usar caracteres de escape, como & lt, & gt, etc .; a outra é usar CDATA para completar, basta escrever o conteúdo dos símbolos especiais em CDATA. Agora suponha que, ao injetar um valor na propriedade bName da classe Book, adicione o número do título do livro "". A implementação é a seguinte:

       (1) Crie a classe Book, forneça os atributos bName e bAuthor e forneça a estrutura de parâmetros.

public class Book {
    private String bName;
    private String bAuthor;

    public Book(String bName, String bAuthor) {
        this.bName = bName;
        this.bAuthor = bAuthor;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bName='" + bName + '\'' +
                ", bAuthor='" + bAuthor + '\'' +
                '}';
    }
}

       (2) Injeção de atributos em bean.xml.

    <!-- 向属性注入特殊字符:使用转义字符   -->
    <bean id="book1" class="com.yht.example1.entity.Book">
        <constructor-arg name="bName" value="&lt;&lt;三国演义&gt;&gt;"></constructor-arg>
        <constructor-arg name="bAuthor" value="罗贯中"></constructor-arg>
    </bean>
    <!-- 向属性注入特殊字符: CDATA  -->
    <bean id="book2" class="com.yht.example1.entity.Book">
        <constructor-arg name="bName">
            <value><![CDATA[<<水浒传>>]]></value>
        </constructor-arg>
        <constructor-arg name="bAuthor" value="施耐庵"></constructor-arg>
    </bean>

        (3) Execute o teste de unidade.

    @Test
    public void testSpecialChar(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Book book1 = (Book) context.getBean("book1");
        System.out.println(book1);
        Book book2 = (Book) context.getBean("book2");
        System.out.println(book2);
    }

       Os resultados da execução são os seguintes:

Dois, injeção de atributo

1, feijão externo

       A maneira do bean externo é apontar a instância configurada em bean.xml por meio do atributo ref . Vamos simplesmente implementar o processo de UserService e UserDao por meio do Spring.

       (1) Crie duas classes UserService e UserDao respectivamente.

public class UserService {
    private UserDao userDao;

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void execute(){
        userDao.findUser();
    }
}

public class UserDao {
    public void findUser(){
        System.out.println("查找用户");
    }
}

        (2) Atribuir e configurar userService e userDao em bean.xml.

    <!--    外部注入bean-->
    <bean id="userService" class="com.yht.example2.service.UserService">
        <!--  ref 属性:创建的userDao对象的bean标签的id值     -->
        <property name="userDao" ref="userDao"></property>
    </bean>
    <bean id="userDao" class="com.yht.example2.dao.UserDao"></bean>

       (3) Execute o teste de unidade.

@Test
    public void testOuterBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.execute();
    }

       Os resultados da execução são os seguintes:

 

        Nota: O valor em ref deve ser consistente com o valor de id da instância de bean especificada.

2. Feijão interno

       O bean interno é equivalente a uma forma aninhada. A diferença entre ele e um bean externo é que o bean interno não precisa escrever um id e não pode ser acessado externamente.

       (1) Crie duas classes de entidade: Emp e Dept.

public class Emp {
    private String empName;
    private Integer age;
    private Dept dept;

    

    public void setEmpName(String empName) {
        this.empName = empName;
    }

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

    public void setDept(Dept dept) {
        this.dept = dept;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "empName='" + empName + '\'' +
                ", age=" + age +
                ", dept=" + dept +
                '}';
    }
}

public class Dept {
    private String deptName;

    public void setDeptName(String deptName) {
        this.deptName = deptName;
    }

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

        (2) Configure o bean interno em bean.xml

    <!--    内部注入bean-->
    <bean id="emp" class="com.yht.example2.entity.Emp">
        <property name="empName" value="王飞"></property>
        <property name="age" value="21"></property>
        <property name="dept">
            <bean id="dept" class="com.yht.example2.entity.Dept">
                <property name="deptName" value="开发部"></property>
            </bean>
        </property>
    </bean>

       (3) Execute o teste de unidade.

    @Test
    public void testInnerBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Emp emp = (Emp) context.getBean("emp");
        System.out.println(emp);
    }

       Os resultados da execução são os seguintes:

 

3. Feijões em cascata

       Spring suporta a configuração de atributos em cascata.O Spring não limita o número de níveis de atributos em cascata.Contanto que o Bean configurado tenha uma estrutura de classe correspondente aos atributos em cascata, qualquer nível de atributos em cascata pode ser configurado. Existem duas maneiras de configurar atributos em cascata: uma é a forma de beans externos; a outra é fornecer o método get do atributo na classe de entidade e, em seguida, concluí-lo por meio do .operador no arquivo de configuração.

       (1) Adicione um método get ao atributo dept na classe Emp.

    public Dept getDept() {
        return dept;
    }

       (2) Configure em bean.xml.

    <!--        级联bean 方式一  -->
    <bean id="employee1" class="com.yht.example2.entity.Emp">
        <property name="empName" value="张帆"></property>
        <property name="age" value="11"></property>
        <property name="dept" ref="dept"></property>
    </bean>
    <bean id="dept" class="com.yht.example2.entity.Dept">
        <property name="deptName" value="开发部"></property>
    </bean>
    <!--    方式二   -->
    <bean id="employee2" class="com.yht.example2.entity.Emp">
        <property name="empName" value="康特"></property>
        <property name="age" value="32"></property>
        <property name="dept" ref="dept"></property>
        <property name="dept.deptName" value="安保部"></property>
    </bean>

       (3) Execute o teste de unidade.

    @Test
    public void testContactBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        Emp emp1 = (Emp) context.getBean("employee1");
        System.out.println(emp1);
        Emp emp2 = (Emp) context.getBean("employee2");
        System.out.println(emp2);
    }

       Os resultados da execução são os seguintes:

Três, injeção de tipos de dados comuns

1. Injeção de tipos de dados básicos e tipos de coleta

       Os tipos de dados básicos no Spring incluem os oito tipos de dados básicos em Java e o tipo String. Aqui, explicamos os métodos de injeção de tipos de dados básicos, Array, lista, conjunto e Mapa, respectivamente.

       (1) Crie a classe ParaTest.

public class ParaTest {
    private String name;
    private String[] strings;
    private List<Integer> lists;
    private Set<Double> sets;
    private Map<Character, String> map;

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

    public void setStrings(String[] strings) {
        this.strings = strings;
    }

    public void setLists(List<Integer> lists) {
        this.lists = lists;
    }

    public void setSets(Set<Double> sets) {
        this.sets = sets;
    }

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

    public void showMessage(){
        System.out.println("name is : " + this.name);
        System.out.println("Strings content are : " + Arrays.toString(this.strings));
        System.out.println("lists content are  : " + this.lists);
        System.out.println("sets content are  : " + this.sets);
        System.out.println("map content are  : " + this.map);
    }
}

       (2) Configure objetos em bean.xml e injete valores.

    <!--  测试基本数据类型和集合数据类型  -->
    <bean id="para" class="com.yht.example2.entity.ParaTest">
        <!--   注入String     -->
        <property name="name" value="郑秀"></property>
        <!--   注入数组     -->
        <property name="strings">
            <array>
                <value>魏国</value>
                <value>蜀国</value>
                <value>吴国</value>
            </array>
        </property>
        <!--   注入list     -->
        <property name="lists">
            <list>
                <value>13</value>
                <value>35</value>
                <value>57</value>
            </list>
        </property>
        <!--   注入set     -->
        <property name="sets">
            <set>
                <value>12.5</value>
                <value>754.1</value>
                <value>89.0</value>
            </set>
        </property>
        <!--   注入map     -->
        <property name="map">
            <map>
                <entry key="a" value="Apple"></entry>
                <entry key="b" value="bar"></entry>
                <entry key="c" value="car"></entry>
                <entry key="d" value="department"></entry>
            </map>
        </property>
    </bean>

       (3) Execute o teste de unidade.

    @Test
    public void testPara(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        ParaTest para = (ParaTest) context.getBean("para");
        para.showMessage();
    }

       Os resultados da execução são os seguintes:

2. Injeção de tipo de objeto

       Em circunstâncias normais, é mais provável que usemos tipos de objetos de injeção. Existem muitos livros para uma pessoa, então como conseguir isso?

        (1) Adicione List <Book> à classe Person e forneça o método set ().

    private List<Book> bookList;

    public void setBookList(List<Book> bookList) {
        this.bookList = bookList;
    }

       (2) Configure em bean.xml.

    <!--  注入对象类型  -->
    <bean id="bookPerson" class="com.yht.example1.entity.Person">
        <property name="name" value="赵峰"></property>
        <property name="age" value="45"></property>
        <property name="bookList">
            <list>
                <ref bean="b1"></ref>
                <ref bean="b2"></ref>
            </list>
        </property>
    </bean>
    <bean id="b1" class="com.yht.example1.entity.Book">
        <constructor-arg name="bName" value="三国演义"></constructor-arg>
        <constructor-arg name="bAuthor" value="罗贯中"></constructor-arg>
    </bean>
    <bean id="b2" class="com.yht.example1.entity.Book">
        <constructor-arg name="bName" value="水浒传"></constructor-arg>
        <constructor-arg name="bAuthor" value="施耐庵"></constructor-arg>
    </bean>

       (3) Execute o teste de unidade.

    @Test
    public void testObjectPara(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean2.xml");
        Person person= (Person) context.getBean("bookPerson");
        System.out.println(person);
    }

       Os resultados são os seguintes:

 3. Extraia a parte pública

       Agora, suponha que existam muitas pessoas cujos livros são iguais e os livros precisam ser extraídos como uma parte pública. Proceda da seguinte forma:

       (1) Apresente o namespace util no arquivo de configuração do spring.

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">

       (2) Use a tag util para completar a injeção e extração da coleção da lista.

<?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:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
    <bean id="b1" class="com.yht.example1.entity.Book">
        <constructor-arg name="bName" value="三国演义"></constructor-arg>
        <constructor-arg name="bAuthor" value="罗贯中"></constructor-arg>
    </bean>
    <bean id="b2" class="com.yht.example1.entity.Book">
        <constructor-arg name="bName" value="水浒传"></constructor-arg>
        <constructor-arg name="bAuthor" value="施耐庵"></constructor-arg>
    </bean>
    <!--把集合注入部分提取出来-->
    <!-- 提取list集合类型属性注入-->
    <util:list id="bookList">
        <ref bean="b1"></ref>
        <ref bean="b2"></ref>
    </util:list>

    <!-- 提取list集合类型属性注入使用-->
    <bean id="person1" class="com.yht.example1.entity.Person" scope="prototype">
        <property name="name" value="王刚"></property>
        <property name="age" value="40"></property>
        <property name="bookList" ref="bookList"></property>
    </bean>
    <bean id="person2" class="com.yht.example1.entity.Person" scope="prototype">
        <property name="name" value="张凡"></property>
        <property name="age" value="32"></property>
        <property name="bookList" ref="bookList"></property>
    </bean>
</beans>

       (3) Execute o teste de unidade.

    @Test
    public void testCommonContent(){
        ApplicationContext context = new ClassPathXmlApplicationContext("bean3.xml");
        Person person1 = (Person) context.getBean("person1");
        System.out.println(person1);
        Person person2 = (Person) context.getBean("person2");
        System.out.println(person2);
    }

       Os resultados da execução são os seguintes: