5分时时彩注册网址_Java匹马行天下之J2EE框架开发——Spring—>用IDEA开发Spring程序(01)
- 时间:
- 浏览:0
一、创建项目
*注:在IDEA中我创建的Maven项目,不了解Maven的许多人可不也能看我完后 的博客“许多人同时走进Maven——知己知彼”,了解Maven后可不也能看我完后 的博客“Maven的安装与配置”,自行安装,行动起来吧。
二、加载依赖
在pom.xml文件中加在Spring依赖和日志相关依赖
<dependencies> <!--测试相关--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <!--Spring核心基础依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>5.0.2.RELEASE</version> </dependency> <!--日志相关--> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.2</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> </dependencies>
三、项目型态
在main目录下面创建java和resources目录
四、基础代码实现(练手)
- 创建TestDao接口和实现类
- 获得TestDao实现类的实例
- 在完后 开发中,许多人是直接new另一一一还还有一个对象即可。即:`private TestDao dao = new TestDaoImpl();`
- 在学习Spring完后
,将由Spring来创建对象的实例 --> 即:`IoC 控制反转(Inverse of Control)`
完后 可不也能也能 实例对象时,从Spring工厂(容器)中获得即可,可不也能也能 将实现类的全限定名称配置到xml文件中。
创建dao包,在dao包下创建TestDao接口和TestDao接口的实现类,型态如下图:
TestDao接口代码示例:
package dao; public interface TestDao { public void sayHello(); }
TestDaoImpl实现类代码示例:
package dao; public class TestDaoImpl implements TestDao{ @Override public void sayHello() { System.out.println("Hello,Spring!"); } }
在resources资源目录点击右键,依次选折 New-->XML Configuration File-->Spring Config,创建applicationContext.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!--把testDao对象的创建权交给Spring-->
<!-- <bean> 配置可不也能也能 创建的对象
id :用于完后 从Spring容器中获得实例时使用的
class :可不也能也能 创建实例的全限定类名-->
<bean id="testDao" class="dao.TestDaoImpl"></bean> </beans>
创建test包,在test包下创建测试类SpringTest
package test;
import dao.TestDao; import org.junit.jupiter.api.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTest {
@Test
public void demo1(){
// 完后 开发,此人 手写new出对象
TestDao dao= new TestDaoImpl();
dao.sayHello();
}@Test
public void demo2() {
// 现在从spring容器中获得对象实例
// 1 、获得容器
//初始化Spring容器ApplicationContext,加载配置文件
ApplicationContext application = new ClassPathXmlApplicationContext("applicationContext.xml");
// 2、获得内容 ,注意此时可不也能 可不也能 此人 new出对象了,都是从spring容器中获得
//通过容器获取testDao实例
TestDao testDao = (TestDao) application.getBean("testDao");
testDao.sayHello();
}
}
- IoC(Inverse of Control)反转控制的概念,什么都有我将另另一一一还还有一个在线程池中手动创建TestDaoImpl对象的控制权,交由Spring框架管理。
- 简单说,什么都有我创建TestDaoImpl对象的控制权被反转到了Spring框架。
点击测试土办法
左侧的运行按钮,选折
Run,测试代码
运行后控制台显示结果
项目运行成功!!!!!!!
五、Spring入门案例:DI(掌握)
- DI :Dependency Injection :依赖注入
- is a :是另一一一还还有一个,继承。
- has a:有另一一一还还有一个,成员变量,依赖。
class B { private A a; // B类依赖A类,B类使用A类。 } 依赖:另一一一还还有一个对象可不也能也能 使用另另一一一还还有一个对象。 注入:通过setter土办法 进行另另一一一还还有一个对象实例设置。
类似:
class BookServiceImpl { // 完后 开发:接口 = 实现类(service和dao耦合了,写死了,知道具体的实现类是谁,那么我的具体实现类变化,那么这行代码也得跟着变) // private BookDao bookDao = new BookDaoImpl(); // spring完后 (解耦:service实现类使用了dao的接口,另另一一一还还有一个就真不知道具体的实现类是谁了) private BookDao bookDao; setter土办法 } 模拟spring执行过程 创建service实例:BookService bookService = new BookServiceImpl(); => IoC <bean> 创建dao实例:BookDao bookDao = new BookDaoImple(); => IoC 将dao设置给service:bookService.setBookDao(bookDao); => DI <property>
具体代码实现:
实现步骤:
- 创建BookDao接口和实现类
- 创建BookService接口和实现类
- 将dao和service配置到 applicationContext.xml文件中
- 使用api测试
项目型态:
加载依赖:
在pom.xml文件中加在Spring依赖和日志相关依赖
<dependencies> <!--测试相关--> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.11</version> <scope>test</scope> </dependency> <!--Spring核心基础依赖--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-core</artifactId> <version>5.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.0.2.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-expression</artifactId> <version>5.0.2.RELEASE</version> </dependency> <!--日志相关--> <dependency> <groupId>commons-logging</groupId> <artifactId>commons-logging</artifactId> <version>1.2</version> </dependency> <dependency> <groupId>log4j</groupId> <artifactId>log4j</artifactId> <version>1.2.17</version> </dependency> </dependencies>
BookDao接口和实现类
package dao; public interface BookDao { void save(); }
package dao; public class BookDaoImpl implements BookDao { @Override public void save() { System.out.println("实现加在功能"); } }
BookService接口和实现类
package Service; public interface BookService { void addBook(); }
package Service; import dao.BookDao; import dao.BookDaoImpl; public class BookServiceImpl implements BookService { //土办法 一:完后 ,接口=实现类 //private BookDao bookDao= new BookDaoImpl(); //土办法 二:现在,接口+setter土办法 private BookDao bookDao; public void setBookDao(BookDao bookDao){ this.bookDao=bookDao; } @Override public void addBook() { this.bookDao.save(); } }
将dao和service配置到 applicationContext.xml文件中
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- <bean> 配置可不也能也能 创建的对象 id :用于完后 从Spring容器中获得实例时使用的 class :可不也能也能 创建实例的全限定类名--> <!-- 模拟spring执行过程 创建service实例:BookService bookService = new BookServiceImpl(); => IoC <bean> 创建dao实例:BookDao bookDao = new BookDaoImple(); => IoC 将dao实例设置给service实例:bookService.setBookDao(bookDao); => DI <property> <property> 用于进行属性注入 name : Bean的属性名称,通过setter土办法 获得 setBookDao => BookDao => bookDao ref :另另一一一还还有一个Bean的id值的引用 --> <!-- 创建service实例 --> <bean id="bookServiceId" class="Service.BookServiceImpl"> <!-- 将dao实例设置给service实例 --> <property name="bookDao" ref="bookDaoId"></property> <!-- 用于进行属性注入 --> </bean> <!-- 创建dao实例 --> <bean id="bookDaoId" class="dao.BookDaoImpl"></bean> </beans>
使用api测试
创建test包,在test包下创建测试类SpringTest
package test; import Service.BookService; import org.junit.jupiter.api.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SpringTest { @Test public void Test1(){ // 完后 开发,此人 手写new出对象 // BookService bookService = new BookServiceImpl(); // bookService.addBook(); } @Test public void Test2(){ // 现在从spring容器中获得对象实例 // 1 、获得容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 2、获得内容 ,注意此时可不也能 可不也能 此人 new出对象了,都是从spring容器中获得 BookService bookService = (BookService) applicationContext.getBean("bookServiceId"); bookService.addBook(); } }
- DI:Dependency Injection 依赖注入,在Spring框架负责创建Bean对象时,动态的将依赖对象注入到Bean组件。
- getBean("bookServiceId"); 从spring容器中获得指定名称对象的实例时,会先判断本实例对象有无可不也能也能 使用许多实例化对象,可能性设置了< property name="bookDao" ref="bookDaoId">< /property>,说明可不也能也能 使用许多实例化对象,什么都有就根据许多Bean的id值的引用,去spring容器中获得指定名称对象的实例,大约将dao实例设置给service实例。
运行后控制台显示结果
这就成功了,开心一下,通过这另一一一还还有一个案例,多Spring有了初步的理解,加油!
六、Spring的核心API(了解)
api整体了解即可,完后 不使用,在学习过程可不也能也能 。
- BeanFactory :这是另一一一还还有一个
工厂
,用于生成任意Bean。采取延迟加载,第一次调用getBean(); 时才会初始化Bean。(即实例化对象)
- ApplicationContext :是BeanFactory的子接口,功能更强大。(国际化防止、事件传递、Bean自动装配、各种不同应用层的Context实现)。
采取非延时加载,当配置文件被加载时,就进行对象的实例化。
- ClassPathXmlApplicationContext 用于加载classpath(类路径/src)下的xml
- 加载xml运行时位置 --> /WEB-INF/classes/xxx.xml
- FileSystemXmlApplicationContext 用于加载指定盘符下的xml
- 加载xml运行时位置 --> /WEB-INF/xxx.xml
- 通过java web学习过的 ServletContext.getRealPath(); 获得具体盘符
- ClassPathXmlApplicationContext 用于加载classpath(类路径/src)下的xml
示例代码如下:
package test; import Service.BookService; import org.junit.jupiter.api.Test; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; import org.springframework.core.io.ClassPathResource; public class SpringTest { @Test public void Test1(){ // 完后 开发,此人 手写new出对象 // BookService bookService = new BookServiceImpl(); // bookService.addBook(); } @Test public void Test2(){ // 现在从spring容器中获得对象实例 // 1 、获得容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 采取非延时加载,当配置文件被加载时,就进行对象的实例化。 // 2、获得内容 ,注意此时可不也能 可不也能 此人 new出对象了,都是从spring容器中获得 BookService bookService = (BookService) applicationContext.getBean("bookServiceId"); bookService.addBook(); } @Test public void demo3() { // 现在从spring容器中获得对象实例,使用的是BeanFactory,上面可不也能也能 另一一一还还有一个Resource,该Resource又是另一一一还还有一个接口,可不也能也能 找它的实现类ClassPathResource // 1 、获得容器 BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml")); // 2、获得内容 ,注意此时可不也能 可不也能 此人 new出对象了,都是从spring容器中获得 BookService bookService = (BookService) beanFactory.getBean("bookServiceId"); // 采取延迟加载,第一次调用getBean(); 时才会初始化Bean(即实例化对象)。 bookService.addBook(); } }
七、装配Bean:基于XML
3种bean实例化土办法 :
- 使用`默认构造土办法 `实例化
- 使用`静态工厂土办法 `实例化
- 使用`实例工厂土办法 `实例化
使用默认构造土办法 实例化
格式:
<bean id="从Spring容器中获得实例时使用的" class="可不也能也能 创建实例的全限定类名"></bean> 类似:<bean id="userServiceId" class="Service.UserServiceImpl"></bean>
示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码,这里不再赘述!
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
测试代码:
public class TestIoC { @Test public void demo01() { // 完后 开发,此人 手写new出对象 UserService userService = new UserServiceImpl(); // 直接手动创建实例 userService.addUser(); } @Test public void demo02() { // 现在从spring容器中获得对象实例 // 1 、获得容器 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 2、获得内容 ,注意此时可不也能 可不也能 此人 new出对象了,都是从spring容器中获得 UserService userService = (UserService) applicationContext.getBean("userServiceId"); userService.addUser(); } }
使用`静态工厂土办法 `实例化
- 静态工厂:常用与spring整合许多框架(工具)时。
- 静态工厂:用于生成实例对象,所有的土办法 可不也能也能 是static。
示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码,这里不再赘述!
格式:
<bean id="" class="工厂全限定类名" factory-method="静态土办法 名称">
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>
静态工厂类代码:
public class MyBeanFactory { /** * 创建实例的静态工厂,所有的土办法 可不也能也能 是静态的(static)。 * * @return */ public static UserService createService() { return new UserServiceImpl(); } // 还有创建许多实例的静态工厂 // ...... }
测试代码:
TestStaticFactory.java
/** * 第二种实例化Bean 的土办法 :使用静态工厂土办法 实例化 * */ public class TestStaticFactory { @Test public void demo01() { // 完后 :使用自定义的静态实例工厂 UserService userService = MyBeanFactory.createService(); userService.addUser(); } @Test public void demo02() { // 现在:使用spring 工厂:将自定义的静态工厂创建的实例交给spring管理
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = applicationContext.getBean("userServiceId", UserService.class); // 这人 土办法 底层会自动转换
// UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
}
}
注意:当使用JDK版本为1.8时,运行上面的测试代码会突然出現另一一一还还有一个问題图片: java.lang.IllegalArgumentException,
问題图片防止链接:使用Junit测试另一一一还还有一个 spring静态工厂实例化bean 的例子,所有代码都那么问題图片,但会
突然出現java.lang.IllegalArgumentException异常小结:在完后
的开发中,工厂类可不也能
可不也能
许多人去手写,可能性别人可能性写好了,许多人通过编写配置文件
,把别人写好的工厂类拿来,写上要用的土办法
名,但会
把它生产后的实例给Spring存起来,完后
许多人要用那此实例,跟Spring说一下,去拿就可不也能了。
使用`实例工厂土办法 `实例化
实例工厂:可不也能也能 先有工厂的实例对象,但会 通过实例对象去创建对象。特点:提供所有的土办法 都是“非静态”的。
示例中用到的 UserService.java 和 UserServiceImpl.java 代码同上面实例中的代码,这里不再赘述!
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>
静态工厂类代码:
public class MyBeanFactory { /** * 创建实例的工厂,所有土办法 非静态 * * @return */ public UserService createService() { return new UserServiceImpl(); } // 还有创建许多实例的工厂 // ...... }
测试代码:
TestFactory.java
package test; import org.junit.Test; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; /** * 第并都是实例化Bean 的土办法 :使用实例工厂土办法 实例化 * */ public class TestFactory { @Test public void demo01() { // 完后 :使用自定义的实例工厂 // 1、创建工厂实例 MyBeanFactory myBeanFactory = new MyBeanFactory(); // 2、通过工厂实例,获得对象 UserService userService = myBeanFactory.createService(); userService.addUser(); } @Test public void demo02() { // 现在:使用spring 工厂:将自定义的实例工厂创建的实例交给spring管理
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = applicationContext.getBean("userServiceId", UserService.class); // 这人 土办法 底层会自动转换
// UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
}
}
-
一、Bean的种类
-
普通bean :完后 操作的都是普通bean。类似:
< bean id="xxx" class="A" >
,这句代码的意思是:Spring直接创建A的实例,并返回。 -
FactoryBean :是另一一一还还有一个特殊的bean,
具有工厂生成对象能力
,但会 可不也能也能 生成特定的对象。
你会生产对象的bean 可不也能也能 实现FactoryBean 接口,此接口提供土办法 getObject(); 用于获得特定bean。- 示例:
< bean id="xxx" class="FB">
,这句代码的意思是:Spring会先创建FB实例,但会 调用getObject(); 土办法 ,并返回土办法 的返回值。即大约如下两行代码:FB fb = new FB();return fb.getObject();
- 示例:
-
BeanFactory 和 FactoryBean 对比?
- BeanFactory :是另一一一还还有一个生产bean的工厂,用于生成任意的bean。
- FactoryBean :是另一一一还还有一个特殊的bean,用于生成另另一一一还还有一个特定的bean。
- 类似:ProxyFactoryBean ,此工厂bean用于生产代理对象的实例。
< bean id="xxx" class="….ProxyFactoryBean">
,这句代码的意思是:获得代理对象的实例。即AOP使用。
- 类似:ProxyFactoryBean ,此工厂bean用于生产代理对象的实例。
-
spring容器中bean元素id和name属性的区别?
-
在spring容器中加在以下配置:
示例:< bean id="userServiceId" class="com.itheima.a_ioc.UserServiceImpl">
-
bean节点中id和name的区别:
-
区别一:
- id : 指定唯一实例引用
- name : 可不也能指定多个实例引用,类似name="名称1, 名称2"
-
区别二:
-
id :id的命名要满足XML对ID属性命名规范
类似:可不也能也能 以字母结束了,可不也能使用字母、数字、连字符、下划线、句话、冒号 -
name : 可能性Bean的名称中中有 特殊字符,就可不也能也能 使用name属性
类似 :< bean name="# boy" class="cn.itheima.ioc.Boy"/>
-
可能性name属性可不也能相同,所完后 突然出現Bean会覆盖完后 突然出現的同名的Bean。
-
总结:项目开发的完后 ,强烈要求用id,可能性id可不也能表示唯一引用。
-
-
-
二、Bean的作用域
Bean 的作用域:用于选折 spring所创建bean 的实例个数。
- 取值:
- singleton 单例,默认值。
- prototype 多例,每执行一次getBean() 将获得另一一一还还有一个实例。类似:在struts整合spring时,可不也能也能 配置action为多例。
- 配置示例:默认状况下会在容器启动时初始化bean,但许多人可不也能指定Bean节点的
lazy-init="true"
来延迟初始化bean,这完后 ,可不也能也能 第一次获取bean会才初始化bean。- 类似:`< bean id="xxx" class="xxx" scope="xxx">`
类似:< bean id="xxx" class="service.UserServiceImpl" lazy-init="true">
- 可能性想对所有bean都应用延迟初始化,可不也能在根节点beans设置
default-lazy-init="true"
,
类似:< beans default-lazy-init="true“>
- Portlet是基于java的web组件,由portlet容器管理,并由容器防止请求,生产动态内容。
- Portals使用portlets作为可插拔用户接口组件,提供信息系统的表示层。
- 作为利用servlets进行web应用编程的下一步,portlets实现了web应用的模块化和用户中心化。
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="userServiceId" class="com.itheima.d_scope.UserServiceImpl" scope="prototype"></bean>
</beans>
测试代码:
TestScope.java
public class TestScope { @Test public void demo01() { // 现在:使用spring 工厂
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService1 = applicationContext.getBean("userServiceId", UserService.class);
// 这人 土办法 底层会自动转换
UserService userService2 = applicationContext.getBean("userServiceId", UserService.class);
// 这人 土办法 底层会自动转换
// 默认Bean的作用域是单例,什么都有打印的对象的地址是一样的
// System.out.println(userService1); // service.UserServiceImpl@2ac273d3
// System.out.println(userService2); // service.UserServiceImpl@2ac273d3
// 现在在配置文件中加在scope属性,值为prototype,此时Bean的作用域变为多例了,再次打印,输出地址不一样了
System.out.println(userService1);
//service.UserServiceImpl@6641000dd7
System.out.println(userService2);
//service.UserServiceImpl@52a86356
}
}
-
三、Bean的生命周期
Bean 的生命周期详情
- instantiate bean 对象实例化。
- populate properties 封装属性。
- 可能性Bean实现 BeanNameAware,则表示执行
setBeanName
。 - 可能性Bean实现 BeanFactoryAware 可能性 ApplicationContextAware,则表示设置实例工厂(
setBeanFactory
)可能性上下文对象(setApplicationContext
)。 - 可能性趋于稳定类实现 BeanPostProcessor(后防止Bean),则表示执行
postProcessBeforeInitialization
。 - 可能性Bean实现 InitializingBean,则表示执行
afterPropertiesSet
。 - 调用
,则表示指定初始化土办法
init
。 - 可能性趋于稳定类实现 BeanPostProcessor(防止Bean),则表示执行
postProcessAfterInitialization
。 - 执行业务防止
- 可能性Bean实现 DisposableBean,则表示执行
destroy
。 - 调用
,则表示指定销毁土办法
customerDestroy
。
-
四、Bean 的初始化和销毁
目标土办法 执行前和执行后,将进行Bean的初始化或销毁。
示例:<bean id="xxx" class="xxx" init-method="初始化的土办法
名称" destroy-method="销毁的土办法
名称"></bean>
示例代码如下:
编写目标类代码:
UserService.java
public interface UserService { void addUser(); }
UserServiceImpl.java
public class UserServiceImpl implements UserService { @Override public void addUser() { System.out.println("e_lifecycle add user"); } public void myInit() { System.out.println("我的初始化土办法 "); } public void myDestory() { System.out.println("我的销毁土办法 "); } }
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>
编写测试代码:
public class TestLifecycle { @Test public void demo01() throws Exception { // 现在:使用spring 工厂(spring 容器)
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser(); // 要想使我的销毁土办法 也执行,必可不也能也能 求:
// 1.容器可不也能也能 先close,我的销毁土办法 才会执行;
// 2.可不也能也能 是单例的(spring所创建该bean的实例个数可不也能也能 另一一一还还有一个)即bean中的scope配置成默认即可。
// 可能性此close土办法 在接口 ApplicationContext 中那么定义,而在实现类中提供了该土办法 ,许多人可不也能使用反射,可能性反射最后执行的什么都有我实现类中的土办法 。
applicationContext.getClass().getMethod("close").invoke(applicationContext); } }
-
五、BeanPostProcessor 后防止Bean
- 是由spring提供的并都是机制,假如有一天实现类实现此接口BeanPostProcessor,并将该实现类提供给spring容器,spring容器将自动执行另一一一还还有一个土办法
:在初始化土办法
前执行before()土办法
,在初始化土办法
后执行after()土办法
。配置格式:
这句代码的意思什么都有我:把实现类提供给了spring容器。
- Factory hook(勾子) that allows for custom modification of new bean instances, e.g. checking for marker interfaces or wrapping them with proxies.
- spring提供工厂勾子,用于修改实例对象,可不也能生成代理对象。(是AOP底层)
谷歌翻译:Factory hook(勾子),允许自定义修改新的bean实例,类似:检查标记接口或用代理包装它们。
许多人来模拟这句话的意思:
before() => postProcessAfterInitialization(Object bean, String beanName) after() => postProcessBeforeInitialization(Object bean, String beanName) A a = new A(); a = B.before(a); // 将a的实例对象传递给后防止bean,可不也能那此都没做,也可不也能做许多事情,比如:生成jdk代理对象并返回给a,另另一一一还还有一个a就从实例对象变成代理对象了,此时的a就具有了AOP功能;再比如,可能性把null返回给a,再用a去调用土办法 ,就会突然出現空指针异常。 a.init(); a = B.after(a); // 以下是AOP演示: // 许多人现在在后防止Bean 代码执行完完后 ,把jdk代理对象返回给a。让a在调用addUser()完后 先做许多事情 // 完后 要做的事情 a.addUser(); // 在目标土办法 的前后可不也能做许多事情,类似:开启事务、提交事务、性能监控(前后时间)等等 // 完后 要做的事情 a.destroy();
目标类示例代码如下:
UserService.java
public interface UserService { void addUser(); }
UserServiceImpl.java
public class UserServiceImpl implements UserService { @Override public void addUser() { System.out.println("e_lifecycle add user"); } public void myInit() { System.out.println("我的初始化土办法 "); } public void myDestory() { System.out.println("我的销毁土办法 "); } }
实现类示例代码如下:
MyBeanPostProcessor.java
public class MyBeanPostProcessor implements BeanPostProcessor { @Override public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { System.out.println("执行了前土办法 :" + beanName); return bean; } @Override public Object postProcessAfterInitialization(final Object bean, String beanName) throws BeansException { System.out.println("执行了后土办法 :" + beanName); // 传入的参数bean是许多人的目标对象,此时许多人的目标对象可不也能也能 另一一一还还有一个接口,那么许多人的代理对象也可不也能也能 另一一一还还有一个接口 // 生成jdk代理对象 return Proxy.newProxyInstance( MyBeanPostProcessor.class.getClassLoader(), // 代理对象 bean.getClass().getInterfaces(), // 目标对象 new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("---开启事务---"); Object obj = method.invoke(bean, args); // 执行目标土办法 ,本例中的目标土办法 是addUser System.out.println("---关闭事务---"); return obj; } }); // 代理的防止线程池 } }
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>
测试示例代码如下:
TestLifecycle.java
public class TestLifecycle { @Test public void demo01() throws Exception { // 现在:使用spring 工厂(spring 容器) ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userServiceId");
userService.addUser();
// 要想使我的销毁土办法 也执行,必可不也能也能 求:
// 1.容器可不也能也能 先close,我的销毁土办法 才会执行;
// 2.可不也能也能 是单例的(spring所创建该bean的实例个数可不也能也能 另一一一还还有一个)即bean中的scope配置成默认即可。
// 可能性此close土办法 在接口 ApplicationContext 中那么定义,而在实现类中提供了该土办法 ,许多人可不也能使用反射,可能性反射最后执行的什么都有我实现类中的土办法 。
applicationContext.getClass().getMethod("close").invoke(applicationContext);
}
}
- 运行结果截图:
- 问題图片1:后防止bean作用某另一一一还还有一个目标类,还是所有目标类?
答:所有。 - 问題图片2:如可只作用另一一一还还有一个?
答:通过获取"参数2"beanName进行控制。类似:"xxx".equals(method.getName());
-
六、依赖注入Bean 的属性(xml)
- 注入依赖对象可不也能采用:
手工装配
或自动装配
。在实际应用中
建议使用手工装配
,可能性自动装配会产生未知状况,开发人员无法预见最终的装配结果。- 手动装配:一般进行配置信息都采用手动装配。
- 基于xml装配基于注解装配 => 完后
讲解
- 构造土办法 注入
- 属性setter土办法 注入
- 接口注入(spring不支持)
- 基于xml装配基于注解装配 => 完后
讲解
- 自动装配:在struts 和spring 整合的完后
使用自动装配。
- byType:按类型装配
- byName:按名称装配
- constructor:按构造装配
- autodetect:不选折 装配(即自动装配)
- 手动装配:一般进行配置信息都采用手动装配。
构造土办法
Bean对象类:
public class User { private Integer uid; private String username; private Integer age; public User(Integer uid, String username) { // 构造土办法 一 super(); this.uid = uid; this.username = username; } public User(String username, Integer age) { // 构造土办法 二 super(); this.username = username; this.age = age; } // 省略getter 和 setter 土办法 // ......
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> </beans>
setter土办法
在spring容器中进行配置:
applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/10001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">