前述
因为前几日刚刚学完 Spring 的基础, 因此写一篇博客整理一下相关的基础知识.
什么是 Spring?
Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架, 帮助分离项目组件之间的依赖关系., 来源于 Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分理念和原型衍生而来.
Spring:SE/EE 开发的一站式框架.
一站式框架: 有 EE 开发的每一层解决方案.
web 层 :SpringMVC
Service 层 :Spring 的 Bean 管理, Spring 声明式事务
DAO 层 :Spring 的 Jdbc 模板, Spring 的 ORM 模块
Spring 框架的优点
非侵入式设计:
非侵入式指应用程序代码对框架的依赖最小化, 即不需要用户代码引入框架代码的信息, 从类的编写者角度来看, 察觉不到框架的存在.
方便解耦, 简化开发:
通过 Spring 提供的 IoC 容器, 我们可以将对象之间的依赖关系交由 Spring 进行控制, 避免硬编码所造成的过度程序耦合. 有了 Spring, 用户不必再为单实例模式类, 属性文件解析等这些很底层的需求编写代码, 可以更专注于上层的应用.
支持 AOP 编程:
AOP(Aspect Oriented Programming)面向切面编程. Spring 提供了对 AOP 的支持, 它允许将一些通用任务, 如安全, 事务, 日志等进行集中式处理, 从而提高了程序的复用性.
支持声明式事务处理:
只需要通过配置就可以完成对事务的管理, 不需要手动编程.
方便程序的测试:
Spring 对 Junit4 支持, 可以通过注解方便的测试 Spring 程序.
方便集成各种优秀框架:
Spring 可以降低各种框架的使用难度, Spring 提供了对各种优秀框架 (如 Struts,Hibernate,Hessian,Quartz) 等的直接支持.
降低 Java EE API 的使用难度:
Spring 对很多难用的 Java EE API(如 JDBC,JavaMail, 远程调用等)提供了一个薄薄的封装层, 通过 Spring 的简易封装, 这些 Java EE API 的使用难度大为降低.
Spring 的框架结构
Data Access/Integration 层 (数据访问 / 集成) 包含有 JDBC,ORM,OXM,JMS 和 Transaction 模块.
Web 层包含了 Web,Web-Servlet,WebSocket,Web-Porlet 模块.
AOP 模块提供了一个符合 AOP 联盟标准的面向切面编程的实现.
Core Container(核心容器): 包含有 Beans,Core,Context 和 SpEL 模块.
Test 模块支持使用 JUnit 和 TestNG 对 Spring 组件进行测试.
Spring 的框架包
官方下载地址: https://repo.spring.io/webapp/#/artifacts/browse/tree/General/libs-release-local/org/springframework/spring
选择相应的版本下载就可以了, 注意: jdk1.7 只能和 spring4.0 以下的包搭配使用, 而你要是用 Spring4.0 以上的包就要用 jdk1.8.0 乃至以上的版本.
说明
下面对照结构图说一下每个 jar 包的作用
spring4 中的 jar 包一共有 20 个
Core 部分包含 4 个模块
spring-core: 依赖注入 IoC 与 DI 的最基本实现
spring-beans:Bean 工厂与 bean 的装配
spring-context:spring 的 context 上下文即 IoC 容器
spring-expression:spring 表达式语言
AOP 部分包含 4 个模块
spring-aop: 面向切面编程
spring-aspects: 集成 AspectJ
spring-instrument: 提供一些类级的工具支持和 ClassLoader 级的实现, 用于服务器
spring-instrument-tomcat: 针对 tomcat 的 instrument 实现
Data Access/Integration 部分包含 5 个模块
spring-jdbc:jdbc 的支持
spring-tx: 事务控制
spring-ORM: 对象关系映射, 集成 ORM 框架
spring-oxm: 对象 xml 映射
spring-jms:java 消息服务
Web 部分包含 3 个模块
spring-Web: 基础 Web 功能, 如文件上传
spring-webmvc:mvc 实现
spring-webmvc-portlet: 基于 portlet 的 mvc 实现
spring-websocket: 为 Web 应用提供的高效通信工具
Test 部分一个模块
spring-test:spring 测试, 提供 junit 与 mock 测试功能
剩下的包是
spring-messaging: 用于构建基于消息的应用程序
spring-context-support:spring 额外支持包, 比如邮件服务, 视图解析等
除了 Spring 的包之外, 在开发中还会用到一个依赖包, 即
下载地址: http://commons.apache.org/proper/commons-logging/download_logging.cgi
我的第一个 Spring 程序
创建 Web 项目, 引入核心 jar 包
创建 pojo, 描述一个 User, 有 name 和 id
- package spring_test1.pojo;
- /**
- * @author jyroy
- *
- */
- public class User {
- private String name;
- private int id;
- public String getName() {
- return name;
- }
- public void setName(String name) {
- this.name = name;
- }
- public int getId() {
- return id;
- }
- public void setId(int id) {
- this.id = id;
- }
- @Override
- public String toString() {
- return "User [name=" + name + ", id=" + id + "]";
- }
- }
编写配置文件
编写配置文件要做的就是将类交给 Spring 管理
在 src 目录下新建 Spring 核心的配置文件 applicationContext.xml
这个配置文件要怎么写呢?
首先要写的, 就是 xml 配置文件的约束, 那约束怎么写呢? 只要去 spring-framework-4.3.20.RELEASE\docs\spring-framework-reference\html\xsd-configuration.HTML 目录下找到相关的约束复制到 xml 中就可以了, 剩下要做的就是对于类的配置了.
- <?xml version="1.0" encoding="UTF-8"?>
- <beans xmlns="http://www.springframework.org/schema/beans"
- xmlns:p="http://www.springframework.org/schema/p"
- 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">
- <!--Spring 的入门的配置 -->
- <bean name="user" class="spring_test1.pojo.User">
- <property name="name" value="李东"/>
- <property name="id" value="1007" />
- </bean>
- </beans>
创建一个测试类
用到了 ApplicationContext, 它是一种常用的 Spring 核心容器. 提供了完整的 IoC 服务支持, 是管理 Bean 的工厂, 主要负责初始化各种 Bean, 并调用 Bran 生命周期的方法, 还包含对国际化, 资源访问, 事件传播等方面的支持.
创建 ApplicationContext 接口实例, 通常有两种方式:
通过 ClassPathXmlApplicationContext 创建, 就是下面例子中用到的方式, new ClassPathXmlApplicationContext("applicationContext.xml") 是 Spring 会去类路径中查找名为 applicationContext.xml 的配置文件.
通过 FileSystemXmlApplicationContext 创建, 从指定的文件系统路径 (绝对路径) 中寻找指定的 xml 配置文件.
- package spring_test1.test;
- import org.junit.Test;
- import org.springframework.context.ApplicationContext;
- import org.springframework.context.support.ClassPathXmlApplicationContext;
- import spring_test1.pojo.User;
- public class UserTest {
- @Test
- public void demo1() {
- // 创建 Spring 的工厂
- ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
- // 通过容器获取 user 对象
- User user = (User) applicationContext.getBean("user");
- System.out.println(user);
- }
- }
结果
IoC 和 DI 简述
IoC (Inversion Of Control): 控制反转. 这是一种设计思想, 就是将原本在程序中手动创建对象的控制权, 交由 Spring 框架来管理.
DI (Dependency Injection): 依赖注入. 将对象依赖属性 (简单值, 集合, 对象) 通过配置设值给该对象.
说明:
上面的例子中, 便应用了 IoC 和 DI, 这里详细的说一下.
可以看到, 我们并没有进行 new 实例化, 但是还是产生对象了, 这就是利用了 IoC 容器, 进行创建对象, 其中 User user = (User) applicationContext.getBean("user"); 便是通过 Spring 容器获取的实现类对象, 而不是通过 new 关键字来创建 user.
其中 name 和 id 的设置便是应用了依赖注入, 通过 set 方法进行的基本数据类型的注入.
传统方式与 IoC 方式对比
传统方式
通过 new 关键字来实例化, 创建对象.
Category c = new Category();
IoC 方式
对象的生命周期由 Spring 来管理, 而不需要通过显式的 new 来实现. 即控制权从本来在自己手里, 现在交给了 Spring.
Category c = Spring 产生.
这篇都是 Spring 介绍和一点点基础. 关于细节的地方没有展开. 我慢慢来.
来源: https://www.cnblogs.com/jyroy/p/10289930.html