三、Spring5.x 与日志框架的整合与属性注入

一、Spring5.x与日志框架的整合

1.1 为什么要整合?

通过整合,可以在控制台中输入Spring框架在运行过程中的一些重要信息
比如bean对象的创建或销毁
好处:便于了解Spring框架的运行过程,利于程序调试

1.2 如何整合?

默认情况下spring框架自带的整合日志框架如下
    |Spring 1、2、3早期都是与commons-logging.jar
    |Spring5.x 默认整合的日志框架 logback logj2
但是我们在这里我们打破默认,要使用log4j日志框架
    1.引入log4j jar包
    2.引入log4j.properties配置文件
  • pom 依赖
<!--log4j 日志框架-->
   <dependency>
      <groupId>org.slf4j</groupId>   <!--这里为对应的日志门面-->
      <artifactId>slf4j-log4j12</artifactId>
      <version>1.7.25</version>
   </dependency>
   <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
   </dependency>
  • log4j.properties
#resources文件夹的根目录下
### 配置根 
log4j.rootLogger = debug.console 
### 日志输出到控制台显示配置
log4j.appender.console=org.apache.log4j.ConsoleAppender
log4j.appender.console.Target=System.out
log4j.appender.console.layout=org.apache.log4j.PatternLayout
log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-ddHH:mm:ss} %-5p %c{1}:%L - %m%n
  • 观察打印出来的日志(运行了junit测试后)
23:29:05.482 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@7bd4937b
23:29:05.849 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 1 bean definitions from class path resource [applicationContext.xml]
23:29:05.905 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'u'
u = cn.paul.spring.demo.hellospring.entity.User@22356acd

说明:从上面的配置文件,我们看到了它加载了这个实现类,然后读取对应的配置文件信息,最后创建了实例

二、注入(Injection)

接下来我们就进入到了Spring最牛逼的地方了,注入。
2.1 什么是注入?
通过Spring工厂及配置文件,为所创建的成员变量赋值(注意是成员变量)
2.2 为什么需要注入?

在上面我们通过工厂获得了对应的bean对象,但是如果我们要设置其对应的成员变量的话,
那么就需要进一步地调用其set()方法了,这样在代码层面将set的内容写死在程序上,其实
也是存在耦合的,所以同一开始解决创建对象的耦合一样,我们通过写配置文件,编码的方式
为对象的成员变量赋值
下面为赋值成员变量的耦合代码情况

存在耦合的set方法
2.3 如何进行注入(具体的开发步骤)
第一步: 因为Spring工厂的本质是利用反射去创建对象(底层调用set方法),所以创建的类必须提供set get方法
第二步: 配置Spring配置文件

<bean name="u,u1" class="cn.paul.spring.demo.hellospring.entity.User">
    <property name="name" value="Paul"/>
    <property name="pwd" value="295179"/>
</bean>

第三步: 调用打印方法检查结果
2.4 Spring注入的原理分析(简易版)
Spring通过底层调用对象属性的set方法,完成对成员变量的赋值,这种方式我们称之为“set注入”

三、注入详解

如上面的配置文件所示,如果是String类型我直接定义一个value属性即可,那么对于其他的数据
类型,需要有改变吗?
在这一节注入详解中,我们主要是说明针对不同类型的成员变量,在<property>标签中,需要
嵌套其他标签的情况
<property>
   xxxx
<property>
下面这张图列举了Spring可能会涉及的不同类型的成员变量注入


3.1 JDK内置类型
3.1.1 String + 8种基本类型

<bean name="u,u1" class="cn.paul.spring.demo.hellospring.entity.User">
    <property name="name" value="Paul"/>
    <property name="pwd" value="295179"/>
</bean>
对于String + 8种基本类型的成员变量,可以使用如上的形式对变量进行注入
注意:通过在<property>标签内部嵌入value属性只能是这String+8种基本类型的属性注入

3.1.2 数组

我们在User类中多定义了一个private String[] names;的数组,下面为对其注入
<bean name="u,u1" class="cn.paul.spring.demo.hellospring.entity.User">
    <property name="names">
        <list>
            <value>paulPaul</value>
            <value>Lily</value>
            <value>Jhon</value>
        </list>
    </property>
</bean>
我们看到其第一步是定义了<property>标签,然后再定义<list>标签,在<list>标签
内部注入我们希望注入的<value>值(可以多个,毕竟是数组嘛)

3.1.3 set集合
首先我们必须知道set集合的特点是“无序且唯一”,所以不管什么形式尽管我们在set集合里面定义了多少个相同的值,最终打印出来都只会有一个,并且打印的顺序很可能是乱序的(尽管你试了都是正序的,但还是要相信权威哦)

我们在User类中多定义了一个private Set tels;的set集合,下面为对其注入
<property name="tels">
    <set>
        <value>114</value>
        <value>110</value>
        <value>110</value>
        <value>110</value>
        <value>112</value>
        <list>
            <value>hi</value>
            <value>hello</value>
            <value>good</value>
        </list>
        <ref bean="account"/>
    </set>
</property>
我们需要关注的是因为我们没有显式声明set集合里面应该含有什么类型的变量,所以它可以
是任何类型,从<set>集合里面内嵌的标签即可看到里面嵌有<value>标签和<list>甚至是
<ref>标签
注意:记住不是所有都是嵌套<value>标签的哦,<value>只是String+8种数据类型的标签而已

3.1.4 List集合

首先List集合的特性是:有序且可重复的
其次在Spring中,其标签的定义和数组的标签定义是一样的,都为<list>,下面为其对应的示例
<property name="addresses">
    <list>
        <value>maoming</value>
        <value>foshan</value>
        <value>guangzhou</value>
        <ref bean="account"/>
    </list>
</property>
注意:记住不是所有都是嵌套<value>标签的哦,<value>只是String+8种数据类型的标签而已

3.1.5 Map集合

首先Map集合是一个由entry键值对类组成的类,我们在java中entry的组成是key-value
所以我们在标签中一定有其对应的映射,下面是对private Map<String,String> qqs的映射
<property name="qqs">
    <map>
        <entry>
            <key><value>paul</value></key>
            <value>78961321</value>
        </entry>
        <entry>
            <key><value>Jhon</value></key>
            <value>1234567131</value>
        </entry>
    </map>
</property>
注意:key所对应的类型为String类型,所以在<key>标签的内部嵌套的是<value>标签;
而刚好键值对所所对应的value的类型是String类型,所以其对应的标签也是<value>标签,
当然value的类型以后未必是String类型,所以这个需要根据不同的数据类型去定义不同的
标签(如<ref>/<set>/<list>标签)
小结:map --> <entry> --> key有特定的标签 <key></key>
                         值根据对应类型选择对应的标签 

3.1.6 Properties类型
首先我们知道Properties类型是一个特殊的Map集合,其键值对组成为<String,String>,根据上面String类型所使用的标签,我们知道其使用应该为<value>标签,但是因为其组成已经是String类型写死的,所有Spring直接使用其自定义的简化版的标签,如下

<property name="p">
    <props>
        <prop key="key1">value1</prop>
        <prop key="key2">value2</prop>
    </props>
</property>
备注:每个<prop>相当于上面Map集合的<entry>,然后key属性映射对应的key名称,标签内
直接写对应的value值·

四、用户自定义类型
除了jdk定义的类外,显然我们还有自定义的类,比如service接口实现类定义的成员变量,xxxDao;
4.1 第一种方式来声明

第一步: 为成员变量提供setter 和 getter 方法
第二步: 配置文件里面进行下面的定义
<bean id="helloService" class="cn.paul.spring.demo.hellospring.service.impl.HelloSeviceImpl">
    <property name="userDao">
        <bean class="cn.paul.spring.demo.hellospring.dao.impl.UserDaoImpl"/>
    </property>
</bean>
备注: 在<property>标签内部的name属性声明的是其接口实现类里面定义的成员变量

4.2 第一种赋值方式的问题

1> 配置文件冗余
eg: 如果一个接口的实现类定义了这个dao对象,那么我另一个类也定义了这个dao对象
那么我就需要定义多次该标签,就写了重复的配置代码
实际例子: UserService的实现类定义了UserDao类
         OrderService的实现类定义了UserDao类
2> 被注入的对象(UserDao)被多次创建,浪费JVM内存资源,这也就慢慢引出了Spring的单例问题了

解决方法:(ref标签的使用)

1> 在代码的层面,像往常一样声明类,并且为成员变量提供setter 和getter方法
2> 在配置文件中ref标签类实现解耦和单例性
<bean id="userDao" class="cn.paul.spring.demo.hellospring.dao.impl.UserDaoImpl"/>
<bean id="helloService" class="cn.paul.spring.demo.hellospring.service.impl.HelloSeviceImpl">
    <property name="userDao">
        <ref bean="userDao"/>
    </property>
</bean>
备注:在Spring4.X 废除了<ref local="" /> ,其等效于<ref bean=""/>
上面的方式还可以简写如下,就是将ref属性嵌入到<property>标签内部:
<bean id="helloService" class="cn.paul.spring.demo.hellospring.service.impl.HelloSeviceImpl">
    <property name="userDao" ref="userDao"/>
</bean>

五、基于p命名空间简化
5.1 JDK类型注入

<!--定义一个bean来演示基于命名空间p的简化-->
<bean id="customer" class="cn.paul.spring.demo.hellospring.entity.Customer"
      p:name="xiaomab" p:account="123456" p:age="18"/>
备注:我们使用P: 来代替<property>标签,然后后面就直接定义名称和值

5.2 用户自定义类型

>首先我们先定义一个bean
<bean id="userDao" class="cn.paul.spring.demo.hellospring.dao.impl.UserDaoImpl"/>
>然后基于命名空间p的简化来注入ref对象
<bean id="helloServiceTestNameSpace"
class="cn.paul.spring.demo.hellospring.service.impl.HelloSeviceNewImpl"
p:userDao-ref="userDao"/>

六、构造注入

注入就是通过Spring的配置文件,为成员变量赋值
之前的set注入,是Spring调用set方法,通过配置文件为成员变量赋值
构造注入就是通过Spring调用构造方法,为成员变量赋值

6.1 开发步骤

    1. 提供有参构造方法(既然是构造注入,那一定有构造方法啦)
public class Palyer implements Serializable {
    private String name;
    private int money;

    public Palyer(String name, int money) {
        this.name = name;
        this.money = money;
    }

    @Override
    public String toString() {
        return "Palyer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
  • 使用<constructor-arg>标签实现对属性的注入
<!--构造方法的注入-->
<bean id="player" class="cn.paul.spring.demo.hellospring.Constructor.Palyer">
    <constructor-arg value="天天"/>
    <constructor-arg value="12"/>
</bean>
注意:上面的value属性只能对应的是String+8种基本类型,如果涉及到其他数据类型,那么就
使用上面的内嵌标签即可
上面的配置也可以写成下面这样
<bean id="player" class="cn.paul.spring.demo.hellospring.Constructor.Palyer">
    <constructor-arg ><value>天天</value></constructor-arg>
    <constructor-arg><value>18</value></constructor-arg>
</bean>

6.2 构造方法重载
首先我们知道重载是指:方法名相同,但是参数的个数、参数的类型、参数的顺序不同(只要符合其中一个条件即可)
6.2.1 参数个数不同的情况

假设现在我们多重载了一个构造方法,如下:
public class Palyer implements Serializable {
    private int money;
    private String name;

    public Palyer(String name, int money) {
        this.name = name;
        this.money = money;
    }
    public Palyer(String name){
        this.name = name;
    }
    @Override
    public String toString() {
        return "Palyer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}    
====================================
我们通过控制配置文件中的<constructor-arg>的数量来控制到底调用哪个构造方法,如下
<bean id="player" class="cn.paul.spring.demo.hellospring.Constructor.Palyer">
    <constructor-arg><value>paul</value></constructor-arg>
</bean>
====================================
那么它就会调用入参是String name的构造方法,创建对象

6.2.2 构造参数个数相同的情况
假设现在我有多个入参的数量都是一个的构造方法,那么这时候就不能通过控制<constructor-arg>的数量来进行构造注入了,我们需要在<constructor-arg>标签内指定type属性

我的类是下面这样的
public class Palyer implements Serializable {
    private int money;
    private String name;

    public Palyer(String name, int money) {
        this.name = name;
        this.money = money;
    }
    public Palyer(String name){
        this.name = name;
    }
    public Palyer(int money){
        this.money= money;
    }

    @Override
    public String toString() {
        return "Palyer{" +
                "name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
====================================
我在配置文件处进行如下的配置(type属性指定int类型)
<bean id="player" class="cn.paul.spring.demo.hellospring.Constructor.Palyer">
    <constructor-arg type="int"><value>15</value></constructor-arg>
</bean>

七、注入总结
不管是set注入还是构造注入,本质都是通过配置文件为成员变量赋值的一种实现手法

问题:未来的实战中应用set注入还是构造注入?
答案: set注入会使用的更多一点
因为:
    1. 构造注入有重载,相对比较麻烦
    2. Spring框架底层,大量使用了set注入

评论

暂无评论