Spring第一章-IOC
一、spring的概述
1. spring 的 开源的轻量级框架
2. spring的两大核心:IOC ,AOP
二、spring的EJB的区别(了解)
1. EJB可以说像是一个Web Service,但也不完全是,比如EJB将编写好的业务组件放置在EJB容器上,然后提供接口给客户端访问;但是功能不仅限如此,EJB标准中提供了很多规范等,而这些规范只有在EJB容器才能正常运行。
EJB重量级框架
2. Spring容器取代了原有的EJB容器,因此以Spring框架为核心的应用无须EJB容器支持,可以在Web容器中运行。
Spring容器管理的不再是复杂的EJB组件,而是POJO(Plain Old Java Object) Bean。
Spring轻量级框架
三、耦合和解耦
1. 什么是耦合
模块之间的关联程度, 依赖程度
2. 什么是解耦
降低模块之间的耦合度(依赖关系)
3. 解耦的目的
编译器不依赖,运行期才依赖
4. 解耦思路
1) 把全限类名都放到配置文件中
2) 通过工厂帮助创建对象
四、解耦代码–自定义IOC(了解)
try {
Driver driver = new Driver();
DriverManager.registerDriver(driver);
} catch (SQLException e) {
e.printStackTrace();
}
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
六、控制反转-- 自定义IOC(了解)
1. 引入依赖
<dependency>
<groupId>dom4j</groupId>
<artifactId>dom4j</artifactId>
<version>1.6.1</version>
</dependency>
<dependency>
<groupId>jaxen</groupId>
<artifactId>jaxen</artifactId>
<version>1.1.6</version>
</dependency>
2. 配置文件
<beans>
<!--
用bean标签配置所有的bean对象
id: 对象的唯一的标志
class:类名
-->
<bean id="userDao" class="com.sgw.dao.impl.UserDaoImpl"></bean>
<bean id="userService" class="com.sgw.service.impl.UserServiceImpl"></bean>
</beans>
3. 创建BeanFactory工厂对象
package com.sgw.factory;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import java.io.InputStream;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class BeanFactory {
private static Map<String ,Object> map = new HashMap<>();
static{
InputStream inputStream = BeanFactory.class.getResourceAsStream("/beans.xml");
SAXReader reader = new SAXReader();
try {
Document doc = reader.read(inputStream);
Element root = doc.getRootElement();
List<Element> beanList = root.elements("bean");
for (Element element : beanList) {
String id = element.attributeValue("id");
String className = element.attributeValue("class");
Class clazz = Class.forName(className);
Object obj = clazz.newInstance();
map.put(id ,obj);
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static Object getBean(String name){
return map.get(name);
}
}
4. 测试
Object userService1 = BeanFactory.getBean("userService");
System.out.println(userService1);
Object userService2 = BeanFactory.getBean("userService");
System.out.println(userService2);
六、spring的IOC入门(掌握)
1. 引入依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.0.2.RELEASE</version>
</dependency>
2. 创建beans.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">
<bean id="userDao" class="com.sgw.dao.impl.UserDaoImpl"></bean>
</beans>
3. 创建容器对象,根据id获取对象
//创建spring的IOC容器
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
//获取对象
Object userDao = ac.getBean("userDao");
System.out.println(userDao);
七、IOC的细节
1、容器对象的类结构图
a、beanFactory 是spring容器的顶层接口
b、接口ApplicationContext是 beanFactory子接口
实现类:ClassPathXmlApplicationContext -- 从类路径之下读取配置文件 (常用)
FileSystemXmlApplicationContext - 从绝对路径指定的配置文件读取
AnnotationConfigApplicationContext -- 纯注解配置使用的类 (常用)
c、BeanFactory与ApplicationContext区别
Resource resource = new ClassPathResource("beans.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);
Object userDao = beanFactory.getBean("userDao");
System.out.println(userDao);
ApplicationContext ac = new ClassPathXmlApplicationContext("beans.xml");
Object userDao2 = ac.getBean("userDao");
System.out.println(userDao2);
2、getBean方法(掌握)
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = ac.getBean("userDao2", UserDao.class);
System.out.println(userDao);
3、bean对象的范围和生命周期(掌握)
springIOC容器默认的单例模式: 单例模式的对象在创建容器时创建,销毁容器时销毁
scope:prototype 原型模式(多例模式):获取时创建,当对象长时间不在被引用, 则被垃圾回收机制回收
scope:singleton :单例模式
scope :request: 请求范围
scope: session : 回话范围
scope:global session :全局范围 -- spring 5的新特性中被删除了
UserDao userDao1 = ac.getBean("userDao", UserDao.class);
System.out.println(userDao1);
UserDao userDao2 = ac.getBean("userDao", UserDao.class);
System.out.println(userDao2);
4、实例化bean的三种方法
1 .<bean id="name" class="全限类名">
getBean(name)
2. 根据静态工厂获取对象
public class StaticFactory {
public static UserDao getUserDao(){
return new UserDaoImpl();
}
}
<!--通过静态工厂创建UserDao对象-->
<!--
factory-method: 工厂方法,返回UserDao对象的方法名
-->
<bean id="userDao" class="com.sgw.factory.StaticFactory" factory-method="getUserDao"></bean>
3. 根据实例(非静态)工厂获取对象
public class InstanceFactory {
public UserDao getUserDao(){
return new UserDaoImpl();
}
}
<!--创建实例工厂对象-->
<bean id="instanceFatory" class="com.sgw.factory.InstanceFactory"></bean>
<!--通过实例工厂创建UserDao对象-->
<bean id="userDao2" factory-bean="instanceFatory" factory-method="getUserDao"></bean>
5、依赖注入(掌握)
a.什么是依赖注入
业务层需要持久层的对象,在配置文件中给业务层传入持久层的对象,就是依赖注入
b. ioc
控制反转包含了依赖注入和依赖查找
6、构造方法注入(掌握)
value 属性只能赋值简单的类型:基本数据类型和String类型
ref: pojo类型,复杂类型, 关联创建好的对象
<bean id="user" class="com.sgw.domain.User">
<constructor-arg name="id" value="3"></constructor-arg>
<constructor-arg name="username" value="王五"></constructor-arg>
<constructor-arg name="sex" value="男"></constructor-arg>
<constructor-arg name="birthday" ref="birthday"></constructor-arg>
</bean>
<bean id="birthday" class="java.util.Date"></bean>
7、set方法注入属性(常用)(掌握)
<bean id="user2" class="com.sgw.domain.User">
<property name="username" value="王朝"></property>
<property name="birthday" ref="birthday"></property>
<property name="sex" value="男"></property>
<property name="id" value="4"></property>
</bean>
8、p名称空间注入:基于set方法注入— 了解
a、在头部文件中引入p名称空间
b、使用p名称空间注入属性
<bean id="user3" class="com.sgw.domain.User"
p:id="5" p:username="马汉" p:sex="男" p:birthday-ref="birthday"
></bean>
9、注入集合属性(掌握)
<bean id="user4" class="com.sgw.domain.User">
<property name="list">
<set>
<value>javaSE</value>
<value>javaEE</value>
<value>javaME</value>
</set>
</property>
<property name="set">
<array>
<value>javaSE</value>
<value>javaEE</value>
<value>javaME</value>
</array>
</property>
<property name="strs">
<list>
<value>javaSE</value>
<value>javaEE</value>
<value>javaME</value>
</list>
</property>
<property name="map">
<props>
<prop key="五" >five</prop>
<prop key="六" >six</prop>
<prop key="七" >seven</prop>
</props>
</property>
<property name="properties">
<map>
<entry key="一" value="one"></entry>
<entry key="二" value="two"></entry>
<entry key="三" value="three"></entry>
<entry key="四" value="four"></entry>
</map>
</property>
</bean>
八、作业
需求
实现账户表的增删改查操作
数据库表:
create table account(
id int primary key auto_increment,
name varchar(40),
money float
) character set utf8 collate utf8_general_ci;
insert into account(name,money) values('aaa',1000);
insert into account(name,money) values('bbb',1000);
insert into account(name,money) values('ccc',1000);
要求
1.独立编写实体类,业务层和持久层代码。(此处不涉及表现层,创建maven的jar工程即可)
2.持久层技术采用dbutils实现。(不要用Mybatis)
3.连接池(数据源)dbcp或者c3p0均可。
4.要求使用junit测试代码。
5.(重点)运用今天所学的spring基于xml的ioc实现业务层和持久层解耦。