1.什么是spirng?
Spring框架是一个开放源代码的J2EE应用程序框架,是针对bean的生命周期进行管理的轻量级容器。spring解决了 开发者在J2EE开发中遇到的许多常见的问题,提供了功能强大IOC ,AOP 及 Web MVC等功能
1.spring的优点
1.方便解耦,简化开发
通过Spring 提供的IOC容器, 我们可以将对象之间的雨来关系交给Spring进行控制,避免硬编码所造成的的过渡程序耦合,有了Spring, 用户不必再为了单实例模式类,属性文件解析等这些很底层的需求编写代码,可以更专注于上层的应用。
2.AOP编程的支持
通过Spring 提供的AOP功能。方便进行面向切面的编程,许多不容易用传统OOP实现的功能可以通过AOP轻松应付
1.3 Spring-framework下载
docs 文件为说明文档
libs 为依赖jar包
schema 为spring约束
2.Spring核心容器
Spring容器会负责控制程序之间的关系,而不是由程序代码直接控制。Spring为我们提供了两种核心器,分别为BeanFactory 和 ApplicationContext
1.BeanFactory
创建BeanFactory实例时,需要体统Spring所管理容器的详细配置信息,这些信息通常采用xml文件形式来管理,其加载配置信息的语法如下:
BeanFactory beanFactory = new xmlBeanFactory(new FileSystemResource("F:/applicationContext.xml"));
ApplicationContext
ApplicationContext是BeanFactory的子接口,是另一种常用的Spring核心容器,它由org.springframework.context.ApplicationContext接口定义,不仅包含了BeanFactory的所有功能,还添加了对国际化、资源访问、事件传播等方面的支持。创建ApplicationContext接口实例,通常采用
两种方法。
1.通过ClassPathXmlApplicationContext创建
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(String configLocation);
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:bean1/bean.xml");
Student student = (Student) applicationContext.getBean("haha");
System.out.println("Student:"+student);
ClassPathXmlApplicationContext 会从类路径classPath中寻找制定的XML配置文件,找到并装在完成ApplicationContext的实例化工作
2.通过FileSystemXmlApplicationContext创建
ApplicationContext applicationContext = new FileSystemApplicationContext(Sting configLocation);
FileSystemXmlApplicationContext
会从指定的文件系统(绝对路径)中寻找指定的XML配置文件,找到并装在完成ApplicationContext的实例化工作。
3.获取Bean实例
创建Spirng容器后,就可以获取Spirng容器中的Bean,Spirng获取Bean的实例通常采用以下两种方法。
- Object getBean(Sting name);
根据容器中Bean的id 或那么来获取指定的Bean , 获取之后需要进行强制类型转换。
Student student = (Student) applicationContext.getBean("haha");
StudentService studentService1 = applicationContext.getBean(StudentService.class);
- T getBean(Class requiredType)
根据类的类型来获取Bean的实例,由此方法为泛型方法,因此在获取Bean之后不需要进行强制类型转换
StudentService studentService = (StudentService) applicationContext.getBean("studentService");
3.spring入门程序
1.创建maven工程,并在pom.xnl中引入以下依赖
<properties>
<!--在当前pom 或者父类pom 中声明属性 -->
<spirng.version>5.0.16.RELEASE</spirng.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spirng.version}</version>
</dependency>
</dependencies>
2.创建配置文件application.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">
<!-- 声明一个 id 为student的 实例 -->
<bean id="student" class="com.wgz.spring.entity.Student">
<property name="name" value="xiaoming"/>
<property name="age" value="18"/>
</bean>
</beans>
3.测试
public class Test {
public static void main(String[] args) {
// 获取容器方式1
// BeanFactory beanFactory = new XmlBeanFactory(new
FileSystemResource("C:\\Users\\Admin\\Desktop\\假期
\\spring\\spring\\spring01\\springdemo\\src\\main\\resources\\application.xml"))
;
// Student student = beanFactory.getBean(Student.class);
// System.out.println("student:"+student);
// 获取容器方式2
// classpath: 加不加都可以
// ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("classpath:application.xml");
// 获取容器方式3
ApplicationContext applicationContext = new
FileSystemXmlApplicationContext("C:\\Users\\Admin\\Desktop\\假期
\\spring\\spring\\spring01\\springdemo\\src\\main\\resources\\application.xml");
// Student student = applicationContext.getBean(Student.class);
Student student = (Student) applicationContext.getBean("student");
System.out.println("student:"+student);
}
}
4.控制反转&依赖注入
控制反转
控制反转,IOC。在使用Spring框架之后,对象的实例不再由调用者来创建,而是由Spring容器来创
建,Spring容器会负责控制程序之间的关系,而不是由调用者的程序代码直接控制。这样,控制权由应
用代码转移到了Spring容器,控制权发生了反转,这就是控制反转。
依赖注入
DI的全称是Dependency Injection,中文称之为依赖注入
从Spring容器的角度来看,Spring容器负责将被依赖对象赋值给调用者的成员变量,这相当于为调用者
注入了它依赖的实例,这就是Spring的依赖注入。
示例
1.分别创建Student对应的Dao,Service实现类
2.创建配置文件
<?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">
<!-- 声明一个 id 为studentDao的 实例 -->
<bean id="studentDao" class="com.wgz.spring.dao.impl.StudentDaoImpl">
</bean>
<!-- 声明一个 id 为studentService的 实例,并将id为 studentDao的实例注入给
StudentServiceImpl-->
<bean id="studentService" class="com.wgz.spring.service.StudentServiceImpl">
<property name="studentDao" ref="studentDao"></property>
</bean>
</beans>
3.测试
public class Test2 {
public static void main(String[] args) {
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("classpath:application.xml");
StudentService studentService =
applicationContext.getBean(StudentService.class);
Student student = studentService.findStudentById(10);
System.out.println("student:"+student);
}
}
5.Bean的配置(BeanFactory 的意思就是只能获取Bean对象,而不能生成Bean对象。 生成Bean对象的的是FactoryBean)
1.什么是Bean?
如果把Spring看桌一个大型工厂,则Spirng容器中的Bean就是该工厂的产品。要想使用这个工厂生产和管理Bean,就需要在配置文件中告诉它需要哪些Bean,以及需要使用何种方式将这些Bean装配到一起。
2.Bean的属性
Bean的配置使用到了xml配置,xml配置文件中的根元素中包含了很多个子元素,每一个子元素定义了一个Bean,并描述了该Bean如何被装配到Spirng容器中,关于元素的常用属性如下表所示:
注意:“id必须是Bean中惟一的,而name可以有很多个”
3.bean的实例化 (实例工厂是连接外部来用的)
在Spirng中,想要使用容器中的Bean,也需要实例化Bean。实例化Bean有三种方式,分别为构造器实例化,静态工厂实例化,和实例工厂方式实例化(其中最常用的是构造器实例化)。
构造器实例化:
这里不展示,因为直接在XML中给Bean里边的属性赋值就行
静态工厂方式实例化
1.创建对应的静态实例化
1.factory.StaticFactory
public class StaticFactory {
public static Student creatStudent(){
Student student = new Student();
// 通过数据获取最新的数据 id name 获取 在set 设置值
System.out.println("去数据查询数据");
// 假装取数据数据得到数据
String name = "小薇";
int id = 2;
student.setId(id);
student.setName(name);
return student;
}
}
2.factory.staticFactory.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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<bean id="student" name="haha" class="com.aaa.test.factory.staticdemo.StaticFactory" factory-method="creatStudent"></bean>
</beans>
3.factory.StaticFactoryTest
public class StaticFactoryTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:factory/staticFactory.xml");
// 更具name 进行获取
Student student = (Student) applicationContext.getBean("student");
System.out.println("student:"+student);
}
}
4.entity.Student
package com.aaa.entity;
/**
* ClassName:Student
* Package:com.aaa.entity
* Description:
*
* @date:2020/7/16 19:41
* @author:lee907463383@qq.com
*/
public class Student {
private int id;
private String name;
private int age;
private int height;
private String sex;
public void init(){
System.out.println("Student 初始化");
}
public void destroy(){
System.out.println("Student 销毁");
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
", height=" + height +
", sex='" + sex + '\'' +
'}';
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public int getHeight() {
return height;
}
public void setHeight(int height) {
this.height = height;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
实例工厂方式实例化
1.创建实例工厂 factory.NormalFactory
public class NormalFactory {
public Student creatStudent(){
Student student = new Student();
// 通过数据获取最新的数据 id name 获取 在set 设置值
System.out.println("去数据查询数据");
// 假装取数据数据得到数据
String name = "小薇";
int id = 2;
student.setId(id);
student.setName(name);
return student;
}
}
2.factory/normalFactory.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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--声明实例工厂-->
<bean id="normalFactory" class="com.aaa.test.factory.normaldemo.NormalFactory"></bean>
<!-- 当初始化bean 时数据如果时动态的,选哟通过网络或者数据获取,可以通过静态工厂,实例工厂 创建对象
目的能够让容器更加灵活的的创建bean
factory-bean="normalFactory" 指向实例工厂
factory-method="createStudent" 执行创建bean的方法
-->
<bean id="student" name="haha" factory-bean="normalFactory" factory-method="creatStudent"></bean>
</beans>
3.com/aaa/test/factory/normaldemo/NormalFactoryTest.java
public class NormalFactoryTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:factory/normalFactory.xml");
// 更具name 进行获取
Student student = (Student) applicationContext.getBean("student");
System.out.println("student:"+student);
}
4.bean的做用域
bean的作用域有7种,最常用的有单例和原型
singleton
singleton是Spring容器默认的作用域,当Bean的作用域为singleton时,Spring容器就只会存在一个共
享的Bean实例。singleton作用域对于无会话状态的Bean(如Dao 组件、Service组件)来说,是最理
想的选择。
1.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">
<!-- 声明一个 id 为student的 实例 -->
<bean id="student1" class="com.wgz.spring.entity.Student" scope="singleton"
>
</bean>
<bean id="student2" class="com.wgz.spring.entity.Student" scope="prototype">
</bean>
</beans>
2.测试
public class ScopeTest {
public static void main(String[] args) {
ApplicationContext applicationContext = new
ClassPathXmlApplicationContext("classpath:scopebean.xml");
Student student1_a = (Student) applicationContext.getBean("student1");
Student student1_b = (Student) applicationContext.getBean("student1");
// 单例的作用域对象得到 只有
System.out.println("student1_a == student1_b:"+
(student1_a==student1_b));
// 原型的作用域 得到的对象 有多个
Student student2_a = (Student) applicationContext.getBean("student2");
Student student2_b = (Student) applicationContext.getBean("student2");
System.out.println("student2_a == student2_b:"+
(student2_a==student2_b));
}
}
5.bean的声明周期
**Spring容器可以管理Bean部分作用域的生命周期。有关说明具体如下
**
- singleton
Spring容器可以管理singleton作用域的Bean的生命周期,在此作用域下,Spring能够精确的知道该
Bean何时被创建,何时初始化完成,以及何时被销毁。
- prototype
prototype作用域的Bean,Spring只负责创建,当容器创建了Bean实例后,Bean的实例就交给客户端
代码来管理,Spring容器将不再跟踪其生命周期。
示例:
1.在Student增加声明周期相关的方法
/**
* 初始化方法
*/
public void init(){
System.out.println("对象初始化");
}
/**
* 销毁方法
*/
public void destroy(){
System.out.println("对象销毁了");
}
2.创建lifebean.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">
<!-- 声明一个 id 为student的 实例 -->
<bean id="student1" class="com.wgz.spring.entity.Student" scope="singleton"
init-method="init" destroy-method="destroy">
</bean>
<bean id="student2" class="com.wgz.spring.entity.Student" scope="prototype"
init-method="init" destroy-method="destroy">
</bean>
</beans>
3.测试
import com.wgz.spring.entity.Student;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class LifeTest {
public static void main(String[] args) {
ClassPathXmlApplicationContext applicationContext = new
ClassPathXmlApplicationContext("lifebean.xml");
Student student1_a = (Student) applicationContext.getBean("student1");
// 原型的作用域
Student student2_a = (Student) applicationContext.getBean("student2");
applicationContext.destroy();
}
}
6.什么是Bean的装配?
** Bean的装配可以理解为依赖关系注入,Bean的装配方式即Bean依赖注入的方式。Spring容器支持多
种形式的Bean的装配方式,如基于XML的装配、基于注解(Annotation)的装配和自动装配(其中最
常用的是基于注解的装配)
**
1.基于XML的装配(分为两种)
- 设值注入
使用setter方法注入,必备条件:Bean类必须有一个无参构造方法,Bean类必须为属性提供setter方
法
xml配置
<bean id="student1" class="com.wgz.spring.entity.Student">
<property name="name" value="xiaoming"/>
<property name="age" value="18"/>
<property name="id" value="10"/>
<property name="sex" value="F"></property>
<property name="courseList" >
<list>
<value>"语文"</value>
<value>"数学"</value>
</list>
</property>
</bean>
- 构造方法注入
对应构造方法的每一参数,index为下标,从0开始
<bean id="student2" class="com.wgz.spring.entity.Student">
<constructor-arg index="0" value="10"></constructor-arg>
<constructor-arg index="1" value="xiaoming"></constructor-arg>
<constructor-arg index="2" value="18"></constructor-arg>
<constructor-arg index="3" value="F"></constructor-arg>
<constructor-arg index="4">
<list>
<value>"语文"</value>
<value>"数学"</value>
</list>
</constructor-arg>
</bean>
2.基于Annotation的装配
好处: 来源:
基于XML的装配可能会导致XML配置文件过于臃肿,给后续的维护和升级带来一定的困难。为此,
Spring提供了对Annotation(注解)技术的全面支持。
注入的注解:有三种 1.@Autowired 2.@Qualifier3.@Resource
- @Autowired:用于对Bean的属性变量、属性的setter方法及构造方法进行标注,配合对应的注解处理
器完成Bean的自动配置工作。 - @Qualifier:与@Autowired注解配合使用,会将默认的按Bean类型装配修改为按Bean的实例名称装
配,Bean的实例名称由@Qualifier注解的参数指定。 - @Resource:其作用与Autowired一样。@Resource中有两个重要属性:name和type。Spring将
name属性解析为Bean实例名称,type属性解析为Bean实例类型。
// @Autowired // 根据类型进行注入若有,多个类型的实例,需要配合
@Qualifier("studentDaoImpl2")
// @Qualifier("studentDaoImpl2")
@Resource() // 默认按照注解的字段名称进行装配, 若没有找到根据类型装配,如果对应类型的
实例有多个需要限定
private StudentDao studentDao ;
生成实例的注解: @Component @Repository @ Service @Controller
**@Component:**用于描述Spring中的Bean,它是一个泛化的概念,仅仅表示一个组件。
@Repository:用于将数据访问层(DAO)的类标识为Spring中的Bean 。
@Service:用于将业务层(Service)的类标识为Spring中的Bean。
@Controller:用于将控制层(Controller)的类标识为Spring中的Bean 。
1.半自动注解装配 annotation-config
- 开启注解处理器 @Autowired @ Resource 、@ PostConstruct、@ PreDestroy 相关注解注入生效
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 激活 半自动注入的注解 @Autowired @Qualifier @Resources -->
<context:annotation-config></context:annotation-config>
<bean id="studentService" class="com.aaa.qy114.service.impl.StudentServiceImpl">
</bean>
<bean id="studentDao11111" class="com.aaa.qy114.dao.impl.StudentDaoImpl"></bean>
<bean id="studentDao2" class="com.aaa.qy114.dao.impl.StudentDaoImpl"></bean>
</beans>
2.自动注解 context:component-scan
**扫描 当前包下面的注解@Component @Controller @Service @Repository,生成实例,并装配
@Autowired @Resource
**
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
<!--
扫描 base-package 下面所有 注解 @Component @Service @Controller @Repository 的类生成 对应的实例
并且 激活 自动注入的注解 @Autowired @Qualifier @Resources -->
<context:component-scan base-package="com.aaa"></context:component-scan>
</beans>
总结:
** context:component-scan 具有annotation-config的功能,并且能够生成实例**
3.基于xml的自动装配 基本不用
所谓自动装配,就是将一个Bean自动的注入到到其他Bean的Property中。 Spring的元素中包含一个
autowire属性,我们可以通过设置autowire的属性值来自动装配Bean。autowire属性有5个值,其值及
说明下表所示:
<?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">
<!-- 声明一个 id 为studentDao的 实例 -->
<bean id="studentDao" class="com.wgz.spring.dao.impl.StudentDaoImpl">
</bean>
<!--
autowire="byType" 此时容器中只能有一个对象
autowire="byName" 使用 studentService内部的变量作为id 去获取
autowire="constructor" 必须有构造函数
-->
<bean id="studentService" class="com.wgz.spring.service.StudentServiceImpl"
autowire="constructor">
</bean>
</beans>