1 官方资料
1.1 官网
1.2 进入 Spring5
下拉 projects, 进入 Spring Framework
进入 Spring5 的 github
1.3 在maven项目中导入依赖
<dependencies>
<!--加入spring开发的基本包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.8</version>
</dependency>
<!--加入spring开发切面编程需要的包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.8</version>
</dependency>
</dependencies>1.4 官方文档
在线文档
: https://docs.spring.io/spring-framework/docs/current/reference/html/
离线文档 :
spring-framework-5.3.8\docs\reference\html\index.html
离
线API:spring-framework-5.3.8/docs/javadoc-api/index.html
2 Spring核心内容
上图说明：
（1）Spring
核心学习内容
IOC
、
AOP, jdbcTemplate,
声明式事务
（2）IOC:
控制反转
,
可以管理
java
对象
（3）AOP :
切面编程
（4）JDBCTemplate :
是
spring
提供一套访问数据库的技术
（5）
声明式事务
:
基于
ioc/aop
实现事务管理
（6）IOC, AOP
是重点和难点
3 Spring的几个重要概念
（1）Spring 可以整合其他的框架(Spring 是管理框架的框架)
（2）Spring 有两个核心的概念: IOC 和 AOP
（3）IOC（Inversion Of Control 反转控制）
- 传统的开发模式[JdbcUtils / 反射]
程序------>环境（程序读取环境配置，然后自己创建对象.）
解读：程序员编写程序, 在程序中读取配置信息；创建对象, new 或者 反射方式；使用对象完成任务
- IOC 的开发模式 [EmpAction EmpService EmpDao Emp]
程序<-----容器（容器创建好对象，程序直接使用.）
解读：
1
、
Spring
根据配置文件
xml/
注解
创建对象， 并放入到容器
(ConcurrentHashMap)
中
, 并且可以完成对象之间的依赖
2
、当需要使用某个对象实例的时候
,
就直接从容器中获取即可
3
、程序员可以更加关注如何使用对象完成相应的业务
4. DI—Dependency Injection
依赖注入，可以理解成是
IOC
的另外叫法
.
5. Spring
最大的价值，通过配置，给程序提供需要使用的
web
层
[Servlet
(Action/Controller)
]/Service/Dao/[JavaBean/entity]
对象
,
这个是核心价值所在，也是
ioc
的具体体现
, 实现解耦.
4 Spring快速入门
4.1 需求说明
通过
Spring
的方式(
配置文件)
，获取
JavaBean: Monster
的对象，并给该对象属性赋值，输出该对象信息.
4.2 实现步骤
（1）创建一个maven项目，在pom.xml文件中导入以下依赖
<dependencies>
<!--加入spring开发的基本包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.3.8</version>
</dependency>
<!--加入spring开发切面编程需要的包-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aspects</artifactId>
<version>5.3.8</version>
</dependency>
</dependencies>（2） 创建 Moster 的javabean/entity，无参构造器一定要写
public class Monster {
private Integer monsterId;
private String name;
private String skill;
//全参构造器
public Monster(Integer monsterId, String name, String skill) {
this.monsterId = monsterId;
this.name = name;
this.skill = skill;
}
//无参构造器一定要写，Spring反射创建对象时，需要使用
public Monster() {
}
public Integer getMonsterId() {
return monsterId;
}
public void setMonsterId(Integer monsterId) {
this.monsterId = monsterId;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSkill() {
return skill;
}
public void setSkill(String skill) {
this.skill = skill;
}
@Override
public String toString() {
return "Monster{" +
"monsterId=" + monsterId +
", name='" + name + '\'' +
", skill='" + skill + '\'' +
'}';
}
}（3） 新建一个容器配置文件：鼠标右键目录名 --> new --> XML Configuration --> Spring Config，然后给配置文件取个名字，这里取beans(对于Maven项目XML文件通常在 src/main/resources 目录)
点击 创建 Spring facet ,然后点击确定
（4）在xml文件中配置Moster对象，在beans标签加入以下配置
注意：将class属性值修改为指定类的全路径
<!--
1. 配置monster对象/javabean
2. 在beans中可以配置多个bean
3. 一个bean表示就是一个java对象
4. class属性是用于指定类的全路径->spring底层使用反射创建
5. id属性表示该java对象在spring容器中的id, 通过id可以获取到对象
6. <property name="monsterId" value="100"> 用于给该对象的属性赋值
-->
<bean class="com.spring.bean.Monster" id="monster01">
<property name="monsterId" value="100"/>
<property name="name" value="牛魔王"/>
<property name="skill" value="芭蕉扇"/>
</bean>
<bean class="com.spring.bean.Monster" id="monster02">
<property name="monsterId" value="1001"/>
<property name="name" value="牛魔王~"/>
<property name="skill" value="芭蕉扇~"/>
</bean>（5）新建一个测试类来获取容器中的对象
public class SpringBeanTest {
@Test
public void getMonster(){
//1. 创建容器 ApplicationContext
//2. 该容器和容器配置文件关联
ApplicationContext ioc =
new ClassPathXmlApplicationContext("beans.xml");
//3. 通过getBean获取对应的对象
// 默认返回的是Object , 但是运行类型Monster
//Object monster01 = ioc.getBean("monster01");
Monster monster01 = (Monster) ioc.getBean("monster01");
//4. 输出
System.out.println("monster01=" + monster01 + " 运行类型=" + monster01.getClass());
System.out.println("monster01=" + monster01 + "属性name=" + monster01.getName() +
" monserid=" + monster01.getMonsterId());
//5. 也可以在获取的时候，直接指定Class类型, 可以再次获取
Monster monster011 = ioc.getBean("monster01", Monster.class);
System.out.println("monster011=" + monster011);
System.out.println("monster011.name=" + monster011.getName());
//6. 查看容器注入了哪些bean对象,会输出bean的id
System.out.println("================================");
String[] beanDefinitionNames = ioc.getBeanDefinitionNames();
for (String beanDefinitionName : beanDefinitionNames) {
System.out.println("beanDefinitionName=" + beanDefinitionName);
}
System.out.println("================================");
System.out.println("ok~~~");
}
}
运行结果：
4.3 注意事项
（1）该代码为什么读取到beans.xml文件
ClassPathXmlApplicationContext ioc = new ClassPathXmlApplicationContext("beans.xml");该代码通过类路径加载配置文件，可通过以下方式输出类加载路径
File f = new File(this.getClass().getResource("/").getPath());
System.out.println(f);maven项目的类加载路径是：target\classes
（2）debug 看看 spring 容器结构/机制
（3） 当调用getBean(),方法获取对象时，会去beanDefinitionMap中去查找，如果发生该bean是单例的，就会返回 singletonobject 中初始化好了的对象，如果不是，就会动态的通过反射机制返回一个临时创建的对象
5 实现简单的基于XML配置的Spring
5.1 需求说明
（1）自己写一个简单的 Spring 容器, 通过读取 beans.xml，获取第 1 个 JavaBean: Monster 的
对象，并给该的对象属性赋值，放入到容器中, 输出该对象信息
（2）也就是说，不使用 Spring 原生框架，我们自己简单模拟实现
5.2 思路分析
（1）使用xml的解析技术-Dom4j
（2）读取beans.xml
（3）解析得到monster对象的id,classpath,属性
（4）使用反射，创建对象
（5）放入到ioc容器(hashmap)
（6）提供一个getBean方法
5.3 实现步骤
（1）在maven项目中添加dom4j依赖
第一种方式：如果导入低版本(1.6.1)，需要如下两个依赖
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.1</version>
</dependency>
第二种方式：如果导入高版本(2.0.0)，需要如下一个依赖
<dependency>
<groupId>org.dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>2.0.0</version>
</dependency>
（2）实现容器类 WwjApplicationContext,java
注意：项目系统目录不能有中文，或者会找不到XML文件
package com.spring.wwjApplicationContext;
import com.spring.bean.Monster;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.File;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
* 1. 这个程序用于实现Spring的一个简单容器机制
* 2. 这里实现如何将beans.xml文件进行解析，并生成对象,放入容器中
* 3. 提供一个方法 getBean(id) 返回对应的对象
*/
public class WwjApplicationContext {
private ConcurrentHashMap<String, Object> singletonObjects =
new ConcurrentHashMap<>();
//构造器
//接收一个容器的配置文件 比如 beans.xml, 该文件默认在resources
public WwjApplicationContext(String iocBeanXmlFile) throws Exception {
//1. 得到类加载路径
// String path = this.getClass().getClassLoader().getPath();
String path = this.getClass().getResource("/").getPath();
//2. 创建 Saxreader
SAXReader saxReader = new SAXReader();
//3. 得到Document对象
Document document =
saxReader.read(new File(path + iocBeanXmlFile));
//4. 得到rootDocument
Element rootElement = document.getRootElement();
//5. 得到第一个bean-monster01
Element bean = (Element) rootElement.elements("bean").get(0);
//6. 获取到第一个bean-monster01的相关属性
String id = bean.attributeValue("id");
String classFullPath = bean.attributeValue("class");
List<Element> property = bean.elements("property");
//遍历
Integer monsterId =
Integer.parseInt(property.get(0).attributeValue("value"));
String name = property.get(1).attributeValue("value");
String skill = property.get(2).attributeValue("value");
//7. 使用反射创建对象.=> 回顾反射机制
Class<?> aClass = Class.forName(classFullPath);
//这里o对象就是Monster对象
Monster o = (Monster) aClass.newInstance();
//给o对象赋值
o.setMonsterId(monsterId);
o.setName(name);
o.setSkill(skill);
//8. 将创建好的对象放入到singletonObjects
singletonObjects.put(id, o);
}
public Object getBean(String id) {
return singletonObjects.get(id);
}
}
（3）创建main类测试
package com.spring;
import com.spring.bean.Monster;
import com.spring.wwjApplicationContext.WwjApplicationContext;
public class AppMain {
public static void main(String[] args) throws Exception {
WwjApplicationContext ioc = new WwjApplicationContext("beans.xml");
Monster monster01 = (Monster)ioc.getBean("monster01");
System.out.println("monster01 = " + monster01);
}
}
运行结果：
6 Spring 原生容器底层结构
656
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
