spring核心思想:
1.IoC思想是把实例化对象的权力交给spring框架去做,而依赖注入则是IoC思想的具体实现
2.Spring是一款主流的Java EE 轻量级开源框架,目的是用于简化Java企业级引用的开发难度和开发周期
3. Spring指的是Spring Framework,通常我们称之为Spring框架。Spring框架是一个分层的面向切面的Java应用程序的一站式解决框架,它是Spring技术栈的核心和基础,是为了解决企业级引用开发的复杂性而创建的
4.Spring有两个核心模块:IoC和AOP。
IOC:Inverse of Control的简写,为 控制反转,指把创建对象交给Spring进行管理。(解耦)
AOP:Aspect Oriented Programming 的简写,为 面向对象编程。AOP用来封装多个类的公共行为,将那些与业务无关,却为业务模块共同调用的逻辑封装起来,减少系统的重复代码,降低模块间的耦合度。另外,AOP还解决一些系统层面上的问题,比如日志、事务、权限等
IOC手写从xml文件读取类信息并创建返回一个类的对象
public class BeanUtils {
private Map<String, Object> map = new HashMap<>();
public BeanUtils() throws DocumentException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, NoSuchFieldException {
SAXReader saxReader = new SAXReader();
Document document = saxReader.read(BeanUtils.class.getClassLoader().getResourceAsStream("student.xml"));
Element rootElement = document.getRootElement();
Iterator<Element> iterator = rootElement.elementIterator();
while (iterator.hasNext()) {
Element element = iterator.next();
String id = element.attributeValue("id");
String className = element.attributeValue("class");
Iterator<Element> iterator1 = element.elementIterator();
Class<?> aClass = Class.forName(className);
Constructor<?> constructor = aClass.getConstructor();
Object student = constructor.newInstance();
while (iterator1.hasNext()) {
Element everyObjectElement = iterator1.next();
String shuxing_name = everyObjectElement.attributeValue("name");
String shuxing_value = everyObjectElement.attributeValue("value");
Field field = aClass.getDeclaredField(shuxing_name);
field.setAccessible(true);
String filename = field.getName();
Method method = aClass.getMethod("set" + filename.substring(0, 1).toUpperCase() + filename.substring(1), field.getType());
Object value = null;
if (field.getType().equals(int.class)) {
value = Integer.parseInt(shuxing_value);
} else if (field.getType().equals(String.class)) {
value = shuxing_value;
}
method.invoke(student, value);
}
map.put(id, student);
}
}
public Object getBean(String name) {
return map.get(name);
}
}
public class text {
@Test
public void m1()throws Exception{
//IOC的容器
BeanUtils beanUtils = new BeanUtils();
student s = (student) beanUtils.getBean("student");
System.out.println(s);
}
}
<?xml version="1.0" encoding="UTF-8"?>
<beans>
<bean id="student" class="GZD.javaBean.student">
<property name="id" value="1"></property>
<property name="name" value="viki"></property>
</bean>
</beans>
5. Spring Framework的特点
控制反转:IoC
面向切面编程:AOP
容器:Spring IoC是一个容器,因为它包含并管理组件对象的生命周期;
一站式:在IOC和AOP的基础上可以整合各种企业应用的开源框架和优秀的第三方库,而且在Spring旗下的项目已经覆盖了广泛领域,很多方面的功能性需求可以在Spring Framework 的基础上全部使用Spring来实现
入门案例:
1.引入依赖
<dependencies>
<!-- spring context依赖
当引入此依赖后,表示将Spring的基础依赖引入了
-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.24</version>
</dependency>
</dependencies>
2.创建架构包
3.创建实体类
4.创建spring配置文件(resourses下的.xml文件)
5.在.xml中用标签完成对象创建
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--完成user对象创建
id属性:唯一标识
class属性:要创建的对象所在类的绝对路径
-->
<bean id="user" class="cn.tedu.spring.User"></bean>
</beans>
6. 创建测试类cn.tedu.spring.TestUser进行测试
@Test
public void m(){
// 1.加载spring配置文件,进行对象创建
ClassPathXmlApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("student.xml");
// 2.获取spring创建好的对象
student s1=classPathXmlApplicationContext.getBean("student",student.class);
System.out.println(s1);
}
7.BeanFactory
- BeanFactory是 IOC 容器的核心接口,它定义了IOC的基本功能。
- 特点:在第一次调用getBean()方法时,创建指定对象的实例
BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
8.ApplicationContext
- 代表应用上下文对象,可以获得spring中IOC容器的Bean对象。
- 特点:在spring容器启动时,加载并创建所有对象的实例
- 常用实现类
1. ClassPathXmlApplicationContext 它是从类的根路径下加载配置文件 推荐使用这种。 2. FileSystemXmlApplicationContext 它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。 3. AnnotationConfigApplicationContext 当使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。 ApplicationContext app =new ClassPathXmlApplicationContext("applicationContext.xml");
😍常用方法
-
1. Object getBean(String name); 根据Bean的id从容器中获得Bean实例,返回是Object,需要强转。 2. <T> T getBean(Class<T> requiredType); 根据类型从容器中匹配Bean实例,当容器中相同类型的Bean有多个时,则此方法会报错。 3. <T> T getBean(String name,Class<T> requiredType); 根据Bean的id和类型获得Bean实例,解决容器中相同类型Bean有多个情况。
ApplicationContext app =new ClassPathXmlApplicationContext("student.xml"); System.out.println(app.getId()); System.out.println(app.getBean("student"));
spring配置文件
1.Bean标签基本配置
<bean id="" class=""></bean>
* 用于配置对象交由Spring来创建。
* 基本属性:
id:Bean实例在Spring容器中的唯一标识
class:Bean的全限定名
* 默认情况下它调用的是类中的 无参构造函数,如果没有无参构造函数则不能创建成功。
2.Bean标签范围配置
<bean id="" class="" scope=""></bean>
1. 当scope的取值为singleton时 Bean的实例化个数:
1个 Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean实例 Bean的生命周期:
对象创建:当应用加载,创建容器时,对象就被创建了
对象运行:只要容器在,对象一直活着
对象销毁:当应用卸载,销毁容器时,对象就被销毁了
2. 当scope的取值为prototype时 Bean的实例化个数:多个
Bean的实例化时机:当调用getBean()方法时实例化Bean
Bean的生命周期: 对象创建:当使用对象时,创建新的对象实例
对象运行:只要对象在使用中,就一直活着
对象销毁:当对象长时间不用时,被 Java 的垃圾回收器回收了
3.Bean生命周期配置
<bean id="" class="" scope="" init-method="" destroy-method=""></bean>
* init-method:指定类中的初始化方法名称
* destroy-method:指定类中销毁方法名称
4.Bean实例化三种方式
无参构造方法实例化
它会根据默认无参构造方法来创建类对象,如果bean中没有默认无参构造函数,将会创建失败<bean id="userDao" class="com.easthome.dao.impl.UserDaoImpl"/>
工厂静态方法实例化
依赖的jar包中有个A类,A类中有个静态方法m1,m1方法的返回值是一个B对象。如果我们频繁使用B对象,此时我们可以将B对象的创建权交给spring的IOC容器,以后我们在使用B对象时,无需调用A类中的m1方法,直接从IOC容器获得。
public class StaticFactoryBean { public static UserDao createUserDao(){ return new UserDaoImpl(); } }
<bean id="userDao" class="com.easthome.factory.StaticFactoryBean" factory-method="createUserDao" />
工厂普通方法实例化
依赖的jar包中有个A类,A类中有个普通方法m1,m1方法的返回值是一个B对象。如果我们频繁使用B对象,此时我们可以将B对象的创建权交给spring的IOC容器,以后我们在使用B对象时,无需调用A类中的m1方法,直接从IOC容器获得。
public class DynamicFactoryBean
{
public UserDao createUserDao(){
return new UserDaoImpl();
}
<bean id="dynamicFactoryBean" class="com.easthome.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="dynamicFactoryBean" factorymethod="createUserDao"/>