文章目录
- 一、Spring框架是什么?
- Spring框架特点
- 二、Spring体系结构
- 理解Spring
- 三、Spring框架配置使用流程
- 1、加载配置文件
- 2、初始化使用bean注入
- 3、使用容器获取到bean对象
- 四、实例
一、Spring框架是什么?
Spring 是另一个主流的 Java Web 开发框架,该框架是一个轻量级的应用框架,具有很高的凝聚力和吸引力。Spring 具有简单、可测试和松耦合等特点,不仅可以用于服务器端的开发,也可以应用于任何 Java 应用的开发中
Spring 是分层的 Java SE/EE full-stack 轻量级开源框架,以 IoC(Inverse of
Control,控制反转)和 AOP(Aspect Oriented Programming,面向切面编程)为内核,使用基本的
JavaBean 完成以前只可能由 EJB 完成的工作,取代了 EJB 臃肿和低效的开发模式。在实际开发中,通常服务器端采用三层体系架构,分别为表现层(web)、业务逻辑层(service)、持久层(dao)
从设计上看,Spring 框架给予了 Java 程序员更高的自由度,对业界的常见问题也提供了良好的解决方案
Spring框架特点
- 1)方便解耦,简化开发*
Spring 就是一个大工厂,可以将所有对象的创建和依赖关系的维护交给 Spring 管理。- 2)方便集成各种优秀框架
Spring 不排斥各种优秀的开源框架,其内部提供了对各种优秀框架(如Struts2、Hibernate、MyBatis 等)的直接支持。- 3)降低 Java EE API 的使用难度
Spring 对 Java EE 开发中非常难用的一些 API(JDBC、JavaMail、远程调用等)都提供了封装,使这些 API 应用的难度大大降低。- 4)方便程序的测试* Spring
支持 JUnit4,可以通过注解方便地测试 Spring 程序。- 5)AOP 编程的支持
Spring 提供面向切面编程,可以方便地实现对程序进行权限拦截和运行监控等功能。- 6)声明式事务的支持
只需要通过配置就可以完成对事务的管理,而无须手动编程。
二、Spring体系结构
Spring 框架采用分层架构,根据不同的功能被划分成了多个模块,这些模块大体可分为 Data、Access/Integration、Web、AOP、Aspects、Messaging、Instrumentation、CoreContainer 和 Test
1、 Data Access/Integration(数据访问/集成)
数据访问/集成层包括 JDBC、ORM、OXM、JMS 和 Transactions 模块,具体介绍如下。
JDBC 模块:提供了一个 JDBC 的抽象层,大幅度减少了在开发过程中对数据库操作的编码。
ORM 模块:对流行的对象关系映射 API,包括 JPA、JDO、Hibernate 和 iBatis 提供了的集成层。
OXM 模块:提供了一个支持对象/XML 映射的抽象层实现,如 JAXB、Castor、XMLBeans、JiBX 和 XStream。
JMS 模块:指 Java 消息服务,包含的功能为生产和消费的信息。
Transactions 事务模块:支持编程和声明式事务管理实现特殊接口类,并为所有的 POJO。
2、Web 模块
Spring 的 Web 层包括 Web、Servlet、Struts 和 Portlet 组件,具体介绍如下。
Web 模块:提供了基本的 Web 开发集成特性,例如多文件上传功能、使用的 Servlet 监听器的 IoC 容器初始化以及 Web 应用上下文。
Servlet模块:包括 Spring 模型—视图—控制器(MVC)实现 Web 应用程序。
Struts 模块:包含支持类内的 Spring 应用程序,集成了经典的 Struts Web 层。
Portlet 模块:提供了在 Portlet 环境中使用 MV C实现,类似 Web-Servlet 模块的功能。
3、Core Container(核心容器)
Spring 的核心容器是其他模块建立的基础,由 Beans 模块、Core 核心模块、Context 上下文模块和 Expression Language 表达式语言模块组成,具体介绍如下。
Beans 模块:提供了 BeanFactory,是工厂模式的经典实现,Spring 将管理对象称为 Bean。
Core 核心模块:提供了 Spring 框架的基本组成部分,包括 IoC 和 DI 功能。
Context 上下文模块:建立在核心和 Beans 模块的基础之上,它是访问定义和配置任何对象的媒介。ApplicationContext 接口是上下文模块的焦点。
Expression Language 模块:是运行时查询和操作对象图的强大的表达式语言。
4、 其他模块
Spring的其他模块还有 AOP、Aspects、Instrumentation 以及 Test 模块,具体介绍如下。
AOP 模块:提供了面向切面编程实现,允许定义方法拦截器和切入点,将代码按照功能进行分离,以降低耦合性。
Aspects 模块:提供与 AspectJ 的集成,是一个功能强大且成熟的面向切面编程(AOP)框架。
Instrumentation 模块:提供了类工具的支持和类加载器的实现,可以在特定的应用服务器中使用。
Test 模块:支持 Spring 组件,使用 JUnit 或 TestNG 框架的测试。
理解Spring
1、Bean容器
提供管理Java对象的容器
配置和使用Bean的方式
(1)使用xml文件——Spring Framework本身决定
(2)使用java注解的方式:
前提:配置扫描的包——Spring Framework支持的注解,就会进行自动配置
2、IOC
控制反转〈Inversion of Control,缩写为loC),是面向对象编程中的一种设计原则,可以用来减低计算机代码之间的耦合度。
IoC 是指在程序开发中,实例的创建不再由调用者管理,而是由 Spring 容器创建。Spring 容器会负责控制程序之间的关系,而不是由程序代码直接控制,因此,控制权由程序代码转移到了 Spring 容器中,控制权发生了反转
对象的生命周期不再由程序管理而是交给Spring的Bean容器控制权发生反转
3、DI
依赖注入,为bean对象注入依赖属性
实现方式:属性注入和构造方法注入
1)属性 setter 注入
指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后,调用该 bean 的 setter 方法,即可实现基于 setter 的 DI。
2)构造方法注入
指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现,每个参数代表一个依赖。
三、Spring框架配置使用流程
1、加载配置文件
pom.xml文件
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>org.example</groupId>
<artifactId>javaEE</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<!-- Spring 需要的依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<!-- 日志需要的依赖 -->
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.2.3</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
<encoding>UTF-8</encoding>
</configuration>
</plugin>
</plugins>
</build>
</project>
在 applicationContext.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
https://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
/**
* Spring 开启容器的方式: ApplicationContext 应用上下文(可以配置#营理Bean对象。及其他的工作)
* ClassPathXmLApplicationContext 根据classpath路径,指定一个xml 文件(配置文件)。
*并根据配置文件完成配置工作(Bean的实例化)
*/
ApplicationContext context = new
ClassPathXmlApplicationContext("applications.xml");
}
}
运行
2、初始化使用bean注入
applicationContext.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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--通过bean标签定义bean对象,Spring Bean 容器是通过id来进行管理的,id相当于bean的名称,Spring可以通过id找到bean对象
如果没有提供id,默认以类名首字母小写作为id
默认是单例模式-->
<!--通过无参的构造方法创建一个对象, class,如果该类型没有无参的构造方法,就会报错-->
<bean id="hhh" class="java.lang.String">
<constructor-arg value="bit"/>
</bean>
<!--<bean class="java.lang.String"></bean>--><!--生成一个id为spring的字符串对象-->
</beans>
3、使用容器获取到bean对象
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
/**
* Spring 开启容器的方式: ApplicationContext 应用上下文(可以配置#营理Bean对象。及其他的工作)
* ClassPathXmLApplicationContext 根据classpath路径,指定一个xml 文件(配置文件)。
*并根据配置文件完成配置工作(Bean的实例化)
*/
ApplicationContext context = new
ClassPathXmlApplicationContext("applications.xml");
//通过bean的名称获取bean对象,bean名称就是xml中bean的id
String bit = (String) context.getBean("hhh");
// String bit1 = (String) context.getBean("java.lang.String");
System.out.println(bit);
//通过类型获取bean对象,如果该类型有多个对象,就会报错,只支持一个
String bit1 = (String) context.getBean(String.class);//只支持实例化一个
System.out.println(bit1);
}
}
13:45:11.062 [main] DEBUG org.springframework.context.support.ClassPathXmlApplicationContext - Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6504e3b2
13:45:11.282 [main] DEBUG org.springframework.beans.factory.xml.XmlBeanDefinitionReader - Loaded 1 bean definitions from class path resource [applications.xml]
13:45:11.323 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'hhh'
bit
bit
Process finished with exit code 0
四、实例
applicationContext.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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--通过bean标签定义bean对象,Spring Bean 容器是通过id来进行管理的,id相当于bean的名称,Spring可以通过id找到bean对象
如果没有提供id,默认以类名首字母小写作为id
默认是单例模式-->
<!--通过无参的构造方法创建一个对象, class,如果该类型没有无参的构造方法,就会报错-->
<bean id="hhh" class="java.lang.String">
<constructor-arg value="bit"/> <!--构造方法注入-->
</bean>
<!--<bean class="java.lang.String"></bean>--><!--生成一个id为spring的字符串对象-->
<bean id="d1" class="Duck">
<property name="name" value="lady"/> <!-- //属性注入-->
<property name="age" value="18"/>
</bean>
<bean id="d2" class="Duck2">
<!-- //含有构造方法的注入-->
<constructor-arg name="n" value="烤鸭"/>
<constructor-arg name="a" value="222"/>
</bean>
</bean>
类
public class Duck {
private String name;
private Integer age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Duck{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
有构造方法的类
public class Duck2 {
private String name;
private Integer age;
public Duck2(String n, Integer a) {
this.name = n;
this.age = a;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
@Override
public String toString() {
return "Duck{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
main
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
/**
* Spring 开启容器的方式: ApplicationContext 应用上下文(可以配置#营理Bean对象。及其他的工作)
* ClassPathXmLApplicationContext 根据classpath路径,指定一个xml 文件(配置文件)。
*并根据配置文件完成配置工作(Bean的实例化)
*/
ApplicationContext context = new
ClassPathXmlApplicationContext("applications.xml");
//通过bean的名称获取bean对象,bean名称就是xml中bean的id
String bit = (String) context.getBean("hhh");
// String bit1 = (String) context.getBean("java.lang.String");
System.out.println(bit);
//通过类型获取bean对象,如果该类型有多个对象,就会报错,只支持一个
String bit1 = (String) context.getBean(String.class);//只支持实例化一个
System.out.println(bit1);
Duck duck = (Duck)context.getBean("d1");
System.out.println(duck);
Duck2 duck2 = (Duck2)context.getBean("d2");
System.out.println(duck2);
}
}
14:14:01.665 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'd1'
14:14:01.693 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'd2'
14:14:01.694 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'duck1'
14:14:01.696 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'duck2'
14:14:01.696 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'duck3'
14:14:01.697 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'd1_1'
14:14:01.698 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'd1_2'
14:14:01.698 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'd1_3'
14:14:01.698 [main] DEBUG org.springframework.beans.factory.support.DefaultListableBeanFactory - Creating shared instance of singleton bean 'shop'
bit
bit
Duck{name='lady', age=18}
Duck{name='烤鸭', age=222}