EJB (Enterprise Java Beans) 是基于分布式事务处理的企业级应用程序的组件。Sun公司发布的文档中对EJB的定义是:EJB是用于开发和部署多层结构的、分布式的、面向对象的Java应用系统的跨平台的构件体系结构。
EJB是一个重量级框架:
Spring是一个轻量级的javaEE解决方案,整合了众多优秀的设计模式。
Spring整合的设计模式:
1. 工厂模式
2. 代理模式
3. 模板模式
4. 策略模式
1.广义概念:
面向对象设计中,解决特定问题的经典代码。
2.狭义概念:
GOF4人帮定义的23种设计模式:
工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式、设配器模式、桥接模式、过滤器模式、组合模式、装饰者模式、外观模式、享元模式、代理模式、责任链模式、命令模式、解释器模式、迭代器模式、中介者模式、备忘录模式、观察者模式、状态模式、空对象模式、策略模式、模板模式、访问者模式
1. 概念:创建对象交给工厂,而不是自己new
2. 优势:解耦合
耦合:指代码间的强关联关系,一方的改变会影响另一方。
问题:不利于代码的维护。
User user = new User();
package com.yuziyan.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class BeanFactory {
private static Properties env = new Properties();
static{
try {
//第一步 获得IO输入流
InputStream inputStream = BeanFactory.class.getResourceAsStream("applicationContext.properties");
//第二步 文件内容 封装 Properties集合中 key = userService value = com.yuziyan.UserServiceImpl
env.load(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
/*
对象的创建方式:
1. 直接调用构造方法 创建对象 UserService userService = new UserServiceImpl();
2. 通过反射的形式 创建对象 解耦合
Class clazz = Class.forName("com.yuziyan.basic.UserServiceImpl");
UserService userService = (UserService)clazz.newInstance();
*/
public static UserService getUserService(){
UserService userService = null;
try {
// com.yuziyan.basic.UserServiceImpl
Class clazz = Class.forName(env.getProperty("userService"));
userService = (UserService) clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return userService;
}
public static UserDao getUserDao(){
UserDao userDao = null;
try {
Class clazz = Class.forName(env.getProperty("userDao"));
userDao = (UserDao) clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return userDao;
}
}
自定义配置文件applicationContext.properties:
# 自定义properties文件,存储要管理的类全名
# 在java代码中用对应的Properties集合 来读取这个文件的内容
# Properties是专门处理属性文件的类,以键值对的形式存储
# Properties [userService = com.yuziyan.xxx.UserServiceImpl]
# Properties.getProperty("userService")
userDao=com.yuziyan.basic.UserDaoImpl
userService=com.yuziyan.basic.UserServiceImpl
简单工厂存的问题:存在大量的代码冗余
package com.yuziyan.basic;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
public class BeanFactory {
private static Properties env = new Properties();
static{
try {
//第一步 获得IO输入流
InputStream inputStream = BeanFactory.class.getResourceAsStream("applicationContext.properties");
//第二步 文件内容 封装 Properties集合中 key = userService value = com.yuziyan.UserServiceImpl
env.load(inputStream);
} catch (IOException e) {
e.printStackTrace();
}
}
//通用工厂
public static Object getBean(String key){
Object res = null;
try {
Class clazz = Class.forName(env.getProperty(key));
res = clazz.newInstance();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return res;
}
}
1. 定义类型 (类)
2. 通过配置文件的配置告知工厂(applicationContext.properties)
key = value
3. 通过工厂获得类的对象
Object ret = BeanFactory.getBean("key")
**Spring本质:**工厂 ApplicationContext (applicationContext.xml)
1. JDK1.8+
2. Maven3.5+
3. IDEA2018+
4. SpringFramework 5.1.4
官方网站 www.spring.io
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.1.4.RELEASEversion>
dependency>
1. 配置文件的放置位置:任意位置,没有硬性要求
2. 配置文件的命名:没有硬性要求,但建议:applicationContext.xml
思考:日后应用Spring框架时,需要进行配置文件路径的设置。
ApplicationContext
作用:Spring提供的ApplicationContext这个工厂,用于对象的创建
好处:解耦合
ApplicationContext是接口类型,屏蔽了实现的差异。
非web环境 : ClassPathXmlApplicationContext (main junit)
web环境 : XmlWebApplicationContext
ApplicationContext工厂的对象占用大量内存。
不会频繁的创建对象 : 一个应用只会创建一个工厂对象。
ApplicationContext工厂:一定是线程安全的(多线程并发访问)
1. 创建类型
2. 配置文件的配置 applicationContext.xml
3. 通过工厂类,获得对象
ApplicationContext
|- ClassPathXmlApplicationContext
ApplicationContext ctx = new ClassPathXmlApplicationContext("/applicationContext.xml");
Person person = (Person)ctx.getBean("person");
名词解释
Spring工厂创建的对象,叫做bean或者组件(component)
Spring工厂的相关方法
//这种方式获取对象,不需要强制类型转换
Person person = ctx.getBean("person", Person.class);
System.out.println("person = " + person);
//当前Spring的配置文件中 只能有一个
Person person1 = ctx.getBean(Person.class);
System.out.println("person1 = " + person1);
//获取配置文件中所有bean标签的id值 person person1
String[] beanDefinitionNames = ctx.getBeanDefinitionNames();
for (String beanDefinitionName : beanDefinitionNames) {
System.out.println("beanDefinitionName = " + beanDefinitionName);
}
//根据类型获取配置文件中对应bean标签的id值
String[] beanNamesForType = ctx.getBeanNamesForType(Person.class);
for (String id : beanNamesForType) {
System.out.println("id = " + id);
}
//用于判断是否存在指定id值的bean,不能判断name值
System.out.println(ctx.containsBeanDefinition("a"));
//用于判断是否存在指定id值的bean,可以判断name值
System.out.println(ctx.containsBean("person"));
配置文件中需要注意的细节
只配置class属性
<bean class="com.yuziyan.basic.Person"/>`
com.yuziyan.basic.Person#0
,可以使用 getBeanNamesForType()
等方法验证。 如果这个bean只需要使用一次,那么就可以省略id值
如果这个bean会使用多次,或者被其他bean引用则需要设置id值
name属性
作用:用于在Spring的配置文件中,为bean对象定义别名(小名)
name与id的相同点:
ctx.getBean("id")
或 ctx.getBean("name")
都可以创建对象;
与
等效;name与id的不同点:
别名可以定义多个,但是 id 属性只能有⼀个值;
XML 的 id 属性的值,命名要求:必须以字⺟开头,可以包含 字⺟、数字、下划线、连字符;不能以特殊字符开头 /person
;
XML 的 name 属性的值,命名没有要求,/person
可以。
但其实 XML 发展到了今天:ID属性的限制已经不存在,/person
也可以。
问题:未来在开发过程中,是不是所有的对象,都会交给 Spring ⼯⼚来创建呢?
回答:理论上是的,但是有特例 :实体对象(entity) 是不会交给Spring创建,它由持久层框架进⾏创建。
Spring与日志框架进行整合,日志框架就可以在控制台中,输出Spring框架运行过程中的一些重要的信息。
好处:便于了解Spring框架的运行过程,利于程序的调试
默认日志框架
Spring 1.x、2.x、3.x 早期都是基于commonslogging.jar
Spring 5.x 默认整合的⽇志框架 logback、log4j2
以Spring5.x整合log4j 为例
pom.xml
文件添加log4j
依赖:[^相当于导入了log4j.jar包]
<dependency>
<groupId>org.slf4jgroupId>
<artifactId>slf4j-log4j12artifactId>
<version>1.7.25version>
dependency>
<dependency>
<groupId>log4jgroupId>
<artifactId>log4jartifactId>
<version>1.2.17version>
dependency>
引⼊ log4.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-dd HH:mm:ss} %-5p %c{1}:%L - %m%n
通过Spring工厂及配置文件,为所创建对象的成员变量赋值
通过编码的方式,为成员变量进行赋值,存在耦合
注入的好处:解耦合
public void test3(){
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
Person person = (Person) ctx.getBean("person");
//通过代码为变量赋值, 存在耦合, 如果以后想修改变量的值, 需要修改代码, 重新编译
person.setName("于自言");
person.setAge(16);
System.out.println("person = " + person);
}
前提:类的成员变量提供set get方法
配置Spring配置文件
<bean id="person1" name="p" class="com.yuziyan.basic.Person">
<property name="name">
<value>张无忌value>
property>
<property name="age">
<value>200value>
property>
bean>
Spring通过底层调用对象属性对应的set方法,完成成员变量的赋值,这种方式我们也称之为set注入
针对于不同类型的成员变量,需要在
标签中嵌套其他标签:
<property>
xxxxx
property>
<property name="name">
<value>张无忌value>
property>
<property name="age">
<value>200value>
property>
<property name="emails">
<list>
<value>[email protected]value>
<value>[email protected]value>
<value>[email protected]value>
<value>[email protected]value>
list>
property>
<property name="tels">
<set>
<value>131********value>
<value>159********value>
<value>176********value>
set>
property>
<set>
set>
<property name="address">
<list>
<value>花果山水帘洞value>
<value>铁岭value>
<value>东土大唐value>
list>
property>
<list>
list>
<property name="qqs">
<map>
<entry>
<key><value>周芷若value>key>
<value>备胎value>
entry>
<entry>
<key><value>赵敏value>key>
<value>爱人value>
entry>
map>
property>
<entry>
<key><value>chenynvalue>key>
entry>
<property name="p">
<props>
<prop key="唐僧">白骨精prop>
<prop key="Tom">Jerryprop>
props>
property>
需要自定义类型转换器处理
方式一存在的问题:
- 配置文件代码冗余。
- 被注入的对象(UserDAO),多次创建,浪费(JVM)内存资源。
JDK类型注入:(注意:value
属性 只能简化 8种基本类型+String 注入标签):
<bean id="person2" class="com.yuziyan.basic.Person">
<property name="name">
<value>韩信value>
property>
bean>
<bean id="person2" class="com.yuziyan.basic.Person">
<property name="name" value="韩信"/>
bean>
用户自定义类型注入:
<bean id="userDao" class="com.yuziyan.basic.UserDaoImpl"/>
<bean id="userService" class="com.yuziyan.basic.UserServiceImpl">
<property name="userDao">
<ref bean="userDao"/>
property>
bean>
<bean id="userDao" class="com.yuziyan.basic.UserDaoImpl"/>
<bean id="userService" class="com.yuziyan.basic.UserServiceImpl">
<property name="userDao" ref="userDao"/>
bean>
JDK类型:
<bean id="person3" class="com.yuziyan.basic.Person">
<property name="name">
<value>沙和尚value>
property>
bean>
<bean id="person3" class="com.yuziyan.basic.Person" p:name="沙和尚"/>
用户自定义类型:
<bean id="userDao" class="com.yuziyan.basic.UserDaoImpl"/>
<bean id="userService" class="com.yuziyan.basic.UserServiceImpl">
<property name="userDao">
<ref bean="userDao"/>
property>
bean>
<bean id="userService1" class="com.yuziyan.basic.UserServiceImpl" p:userDao-ref="userDao"/>
构造注入:Spring解析配置文件,调用构造方法,为成员变量赋值。
提供带参数构造方法
public class Customer implements Serializable {
private String name;
private int age;
//带参构造方法:
public Customer(String name, int age) {
this.name = name;
this.age = age;
}
}
Spring配置文件中赋值(注入)
<bean id="customer" class="com.yuziyan.basic.constructor.Customer">
<constructor-arg>
<value>武松value>
constructor-arg>
<constructor-arg>
<value>234value>
constructor-arg>
bean>
通过控制标签的数量进行区分
通过在标签引入 type属性 进行类型的区分
未来的实战中,应用set注入还是构造注入?
答案:set注入更多,原因如下:
含义:指的就是不能直接通过new构造方法创建的对象。
举例:Connection
SqlSessionFactory
开发步骤
实现FactoryBean接口
Spring配置文件中注册
<bean id="conn" class="com.yuziyan.factorybean.ConnectionFactoryBean"/>
注意:
如果class类型是FactoryBean接口的实现类,那么通过id值获得的是这个类getObject()
方法所返回的对象。比如 Connection SqlSessionFactory
由于我们此时想获取的是Connection对象,所以需要在pom.xml文件中加入相关的依赖
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.48version>
dependency>
细节分析
如果就想获得FactoryBean类型的对象,在id前加上&符号,ctx.getBean("&conn")
,此时获得的就是ConnectionFactoryBean对象本身。
isSingleton()
方法,返回 true 只会创建一个复杂对象,返回 false 每一次都会创建新的对象
问题:根据这个对象的特点 ,决定是返回true (SqlSessionFactory) 还是 false (Connection)。
mysql高版本连接创建时,需要制定SSL证书,解决问题的方式。
url = "jdbc:mysql://localhost:3306/suns?useSSL=false"
体会依赖注入(DI)
可以把ConnectionFactoryBean中依赖的4个字符串信息 ,在配置文件中进行注入 ,解耦合。
<bean id="conn" class="com.yuziyan.factorybean.ConnectionFactoryBean">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/test?useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
bean>
FactoryBean的实现原理[简易版]
Spring内部运行流程:
conn
获得ConnectionFactoryBean类的对象。getObject()
方法返回Connection类的对象。体现了接口回调的特点。FactoryBean总结
Spring中用于创建复杂对象的一种方式,也是Spring原生提供的,后续讲解Spring整合其他框架,大量应用FactoryBean
实例工厂的作用:
开发步骤:
定义实例工厂类:
public class ConnectionFactory {
public Connection getConnection(){
//xxxx
return conn;
}
}
Spring配置文件中注册:
<bean id="connFactory" class="com.yuziyan.factorybean.ConnectionFactory"/>
<bean id="conn" factory-bean="connFactory" factory-method="getConnection"/>
静态工厂的作用(同实例工厂):
开发步骤:
定义静态工厂类:
public class StaticConnectionFactory {
public static Connection getConnection(){
//xxxx
return conn;
}
}
Spring配置文件中注册:
<bean id="conn1" class="xxx.StaticConnectionFactory" factory-method="getConnection"/>
为了减少不必要的内存浪费。
什么样的对象只创建一次?
1. SqlSessionFactory
2. DAO
3. Service
...
什么样的对象 每一次都要创建新的?
1. Connection
2. SqlSession | Session
3. Struts2 Action
...
<bean id="account" scope="singleton|prototype" class="xxxx.Account"/>
singleton
:只会创建一次简单对象 默认值
prototype
:每一次都会创建新的对象
FactoryBean{
isSingleton(){
return true;//只会创建一次
return false;//每一次都会创建新的
}
}
//如没有isSingleton方法,还是通过scope属性,进行控制。
含义:一个对象创建、存活、消亡的一个完整过程。
由Spring负责对象的创建、存活、销毁,了解生命周期,有利于我们使用好Spring为我们创建的对象。
scope="singleton"
此时会在创建Spring工厂时,创建对象。
注意:如果同时设置了lazy-init="true"
,那么会在获取对象ctx.getBean("")
时创建。
scope="prototype"
Spring工厂会在获取对象时,创建对象,即调用ctx.getBean("")
方法时创建。
注意:如果有属性需要注入(DI),会在创建完成时立即进行注入。
创建阶段完成后,Spring会调用对象的初始化方法,完成对应的初始化操作。
程序员提供初始化方法的途径:
实现InitializingBean接口:
//实现这个方法,完成初始化操作
public void afterProperitesSet(){
}
对象中提供一个普通的方法同时配置Spring配置文件:
public void myInit(){
}
<bean id="product" class="xxx.Product" init-method="myInit"/>
细节分析:
如果一个对象即实现InitializingBean,同时又提供的普通的初始化方法 ,顺序:
1. InitializingBean
2. 普通初始化方法
注入一定发生在初始化操作的前面
什么叫做初始化操作:资源的初始化:数据库、IO、网络 …
Spring销毁对象ctx.close();
前,会调用对象的销毁方法,完成销毁操作
程序员定义销毁方法的途径:
实现DisposableBean
public void destroy()throws Exception{
}
定义一个普通的销毁方法同时配置Spring配置文件:
public void myDestroy()throws Exception{
}
<bean id="" class="" init-method="" destroy-method="myDestroy"/>
细节分析:
scope="singleton"
io.close();
connection.close();
答:把Spring配置文件中需要经常修改的字符串信息,转移到一个更小的配置文件中。
1. Spring的配置文件中存在需要经常修改的字符串?
存在 以数据库连接相关的参数 代表
2. 经常变化字符串,在Spring的配置文件中,直接修改
不利于项目维护(修改)
3. 转移到一个小的配置文件(.properties)
利于维护(修改)
配置文件参数化:利于Spring配置文件的维护(修改)
# 名字:随便
# 放置位置:随便
jdbc.driverClassName = com.mysql.jdbc.Driver
jdbc.url = jdbc:mysql://localhost:3306/test?useSSL=false
jdbc.username = root
jdbc.password = root
<context:property-placeholder location="classpath:/db.properties"/>
${key}
获取小配置文件中对应的值Spring通过类型转换器把配置文件中字符串类型的数据,转换成对象中成员变量对应类型的数据,进而完成了注入。
原因:实际应用中需要转换某种特定的类型,且Spring内部没有提供这种类型转换器时,需要程序员自己定义。
Converter<>
接口public class MyDateConverter implements Converter<String, Date> {
/*
convert方法作用:String ---> Date
SimpleDateFormat sdf = new SimpleDateFormat();
sdf.parset(String) ---> Date
param:source 代表的是配置文件中 日期字符串 2020-10-11
return : 当把转换好的Date作为convert方法的返回值后,Spring自动的为birthday属性进行注入(赋值)
*/
public Date convert(String source) {
Date date = null;
try {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
date = sdf.parse(source);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}
<bean id="myDateConverter" class="com.yuziyan.converter.MyDateConverter"/>
<bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
<property name="converters">
<set>
<ref bean="myDateConverter"/>
set>
property>
bean>
MyDateConverter
中的日期的格式,可以通过依赖注入的方式,由配置文件完成赋值。public class MyDateConverter implements Converter<String, Date> {
private String pattern;
public String getPattern() { return pattern; }
public void setPattern(String pattern) { this.pattern = pattern; }
/*
convert方法作用:String ---> Date
SimpleDateFormat sdf = new SimpleDateFormat();
sdf.parset(String) ---> Date
param:source 代表的是配置文件中 日期字符串 2020-10-11
return : 当把转换好的Date作为convert方法的返回值后,Spring自动的为birthday属性进行注入(赋值)
*/
public Date convert(String source) {
Date date = null;
try {
SimpleDateFormat sdf = new SimpleDateFormat(pattern);
date = sdf.parse(source);
} catch (ParseException e) {
e.printStackTrace();
}
return date;
}
}
<bean id="myDateConverter" class="com.yuziyan.converter.MyDateConverter">
<property name="pattern" value="yyyy-MM-dd"/>
bean>
ConversionSeviceFactoryBean
定义id属性,值必须是 conversionService
日期格式:2020/05/01 (不支持 :2020-05-01)
对Spring工厂所创建的对象,进行再加工。
注意:BeanPostProcessor是接口
程序员实现BeanPostProcessor规定接口中的方法:
参数一:Spring工厂创建好的对象
参数二:对象名字
返回值:返回的对象会交给Spring框架
Object postProcessBeforeInitiallization(Object bean String beanName)
作用:Spring创建完对象,并进行注入后,会运行Before方法进行加工
Object postProcessAfterInitiallization(Object bean String beanName)
作用:Spring执行完对象的初始化操作后,会运行After方法进行加工
实战中:
很少处理Spring的初始化操作:没有必要区分Before After。只需要实现其中的一个After方法即可
注意:
postProcessBeforeInitiallization(){
return bean对象
}
public class MyBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
Categroy categroy = (Categroy) bean;
categroy.setName("xiaowb");
return categroy;
}
}
<bean id="myBeanPostProcessor" class="xxx.MyBeanPostProcessor"/>
BeanPostProcessor会对Spring工厂中所有创建的对象进行加工。