目录
1.4.2.3 Spring中的IOC 产生的对象是否是单例模式
1.spring介绍
Spring
是一个企业级应用框架。其中包含了大量的各种应用组件。
Spring
框架为现代基于
Java
的企业应用程序提供了一个全面的编程和配置模型，能够在任何类型的部署平台上进行部署。其核心是
IoC
及
AOP
。
spring中的两个核心概念
1.1 IoC
1.IoC (inversion of Controller) 控制反转，将原来的我们完成的实例化过程，交给容器来完成
、将组件对象的控制权从 代码-->转移到外部容器上
2.组件化的思想 ： 使用接口， 不在关注实现
3.DI 依赖注入(Dependency Injection) 依赖于某种媒介完成对某一个对象的初始化 或赋值。
1.2 AoP
2.AOP 面向切面编程（Aspect Oriented Programming）
1.3 Spring的优点
1.独立于各种应用服务器
2.依赖注入特性将组件关系透明化，降低了耦合度
3.面向切面编程的特性允许将通用任务进行 几种处理 --（）
4.与第三方框架的良好整合
1.4 Spring工程构建
1.4.1 Maven Spring 依赖
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.22</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.9.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>5.3.9</version>
</dependency>
</dependencies>1.4.2 Spring核心配置文件编写
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>1.4.2.1 完成控制反转以及依赖注入
bean的id名称，在同一个配置文件下，是只能拥有一个，不能够出现重复的id
名称！
<bean id="gz" class="com.csi.domain.People">
<constructor-arg index="0" value="gz"/>
<constructor-arg index="1" value="打鬼子"/>
</bean>
<bean id="rod" class="com.csi.domain.People">
<constructor-arg index="0" value="rod"/>
<constructor-arg index="1" value="唱歌"/>
</bean>
输出的结果就是：
gz:打鬼子
rod:唱歌1.4.2.2 测试
package com.csi.bean;
import com.csi.domain.People;
import com.csi.service.impl.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestPeople {
@Test
public void TestPeople() {
//步骤1：需要先加载Spring核心配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//步骤2：需要获取到bean的id名称，也就是获取到由容器创建的对象
People people = (People) ctx.getBean("gz");
People people1 = (People) ctx.getBean("rod");
System.out.println(people);
System.out.println(people1);
}
}
1.4.2.3 Spring中的IOC 产生的对象是否是单例模式
1.经过测试 IOC产生的对象是单列模式 线程是安全的 但是也有特定的条件：
1.1什么是单例模式？
保证整个系统中一个类只有一个对象的实例，实现这种功能的方式就叫单例模式。
1.5 Bean的三种实例化方式
1.5.1构造方法方式
userServiceImpl的实现类：
package com.csi.service.impl;
import com.csi.dao.UserDao;
import com.csi.domain.UserInfo;
import com.csi.mapper.UserMapper;
import com.csi.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
@Service
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public UserServiceImpl() {
}
public UserServiceImpl(UserDao userDao) {
this.userDao = userDao;
}
@Autowired
private UserMapper userMapper ;
@Override
public void save() {
this.userMapper.save();
}
@Override
public List<UserInfo> list() {
return this.userMapper.list();
}
@Override
public void update() {
this.userMapper.update();
}
}
applicationContext.xml的配置文件：
<bean id="userdao" class="com.csi.dao.impl.UserDaoImpl"/>
<bean id="userservice" class="com.csi.service.impl.UserServiceImpl">
<property name="userDao" ref="userdao" />
</bean>
测试类：
package com.csi.bean;
import com.csi.service.UserService;
import com.csi.service.impl.UserServiceImpl;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUserServiceImpl {
@Test
public void TestUserService() {
//步骤1：需要先加载Spring核心配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
//步骤2：需要获取到bean的id名称，也就是获取到由容器创建的对象
UserService userService = (UserService) ctx.getBean("userService");
//步骤3：输出结果
userService.save();
}
}
1.5.2 静态工厂方式
1.创建了一个接口
package com.csi.dao;
import java.util.List;
public interface UserDao {
void save() ;
void update() ;
void deleteById(int userId) ;
void findById(int userId) ;
List list() ;
}
2.UserDaoImpl 实现类
package com.csi.dao.impl;
import com.csi.dao.UserDao;
import java.util.List;
public class UserDaoImpl implements UserDao {
@Override
public void save() {
System.out.println("save方法被执行了...");
}
@Override
public void update() {
System.out.println("update方法被执行了...");
}
@Override
public void deleteById(int userId) {
}
@Override
public void findById(int userId) {
}
@Override
public List list() {
System.out.println("list方法被执行了...");
return null;
}
}
3.弄一个静态工厂类：
package com.csi.bean;
import com.csi.dao.UserDao;
import com.csi.dao.impl.UserDaoImpl;
public class ObjectStaticDaoFactory {
public static UserDao getUserDao() {
System.out.println("静态工厂创建了...准备创建对象...");
return new UserDaoImpl() ;
}
}
4.配置信息：
<bean id="userDao" class="com.csi.bean.ObjectStaticDaoFactory" factory-method="getUserDao"/>
5 .测试类
package com.csi.bean;
import com.csi.dao.UserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestUserDao {
@Test
public void test1(){
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) ctx.getBean("userDao");
userDao.save();
System.out.println(userDao);
}
}
6.如果在配置信息中设置了 scope=“prototype” ---原型
则会产生两个不同的对象
静态工厂
1.5.3 实例工厂方式
实例工厂与静态工厂的不同点有两点：
1.在写实例工厂的时候是没有 static的
2.在配置文件信息时是不同的
实例工厂的配置信息是： 它是先设置一个 bean是实例工厂的bean 类
然后在userDao中调用了 上面的 factoryBean 去实现 以及调用实例工厂类下的方法：
getUserDao
<bean id="factoryBean" class="com.csi.bean.ObjectDaoFactory"/>
<bean id="userDao" factory-bean="factoryBean" factory-method="getUserDao"/>
1.6 Bean的生命周期
其定义为：从对象的创建到销毁的过程。而Spring中的一个Bean从开始到结束经历很多过程，但总体可以分为六个阶段Bean定义、实例化、属性赋值、初始化、生存期、销毁。
简单来说，分为四步：
使用无参构造方法去创建了一个Bean
1.实例化（Instantiation）
2.属性设置 (populate)
3.初始化 (initialization)
4.销毁 (Destruction)
1.6.1 Bean的销毁时机
在容器关闭你之前触发bean 的销毁
关闭容器的方式：
- 手工关闭：ConfigurableApplicationContext 接口 close() 操作
- 注册关闭钩子，在虚拟机退出全先关闭容器在退出虚拟机：ConfigurableApplicationContext 接口 registerShutdownHook() 操作
56万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
