三、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的内容写死在程序上,其实
也是存在耦合的,所以同一开始解决创建对象的耦合一样,我们通过写配置文件,编码的方式
为对象的成员变量赋值
下面为赋值成员变量的耦合代码情况
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 开发步骤
- 提供有参构造方法(既然是构造注入,那一定有构造方法啦)
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注入
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论