1.Spring
https://spring.io
简化开发: Spring框架中提供了两个大的核心技术，分别是:
- IOC
- AOP
- 事务处理
框架整合: Spring在框架整合这块已经做到了极致，它可以整合市面上几乎所有主流框架
架构图：
(1)核心层：
- Core Container:核心容器，这个模块是Spring最核心的模块，其他的都需要依赖该模块
(2)AOP层
- AOP:面向切面编程，它依赖核心层容器，目的是在不改变原有代码的前提下对其进行功能增强
- Aspects:AOP是思想,Aspects是对AOP思想的具体实现
(3)数据层
- Data Access:数据访问，Spring全家桶中有对数据访问的具体实现技术
- Data Integration:数据集成，Spring支持整合其他的数据层解决方案，比如Mybatis
- Transactions:事务，Spring中事务管理是Spring AOP的一个具体实现
(4)Web层
- 这一层的内容将在SpringMVC框架具体学习
使用需要添加spring的jar包
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>5.2.10.RELEASE</version>
</dependency>
</dependencies>
其中applicationContext.xml文件放在resources的下面
1.IOC执行所需要的代码
ApplicationContext ctx=new ClassPathXmlApplicationContext("applicationContext.xml");
xxx bookService = (xxx) ctx.getBean("bean的名字");
bookService.方法名();
2.DI执行所需要的代码
<!--bean标签标示配置bean
id属性标示给bean起名字
class属性表示给bean定义类型
scope：表示单例 ...
-->
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl">
<!--配置server与dao的关系-->
<!--property标签表示配置当前bean的属性
name属性表示配置哪一个具体的属性
ref属性表示参照哪一个bean
-->
<property name="bookDao" ref="bookDao"/>
</bean>
1.IOC（Inversion of Control）控制反转
使用对象时，由主动new产生对象转换为由外部提供对象，此过程中对象创建控制权由程序转移到外部，此思想称为控制反转。
2.DI:依赖注入，绑定对象与对象之间的依赖关系
3.容器中所存放的一个个对象就叫Bean或Bean对象
1.IOC
ApplicationContext ctx=new ClassPathXmlApplicationContext(“applicationContext.xml”);
-------创建IOC容器
1. bean的name属性
<!--name:为bean指定别名，别名可以有多个，使用逗号，分号，空格进行分隔-->
<bean id="bookService" name="service service4 bookEbi" class="com.itheima.service.impl.BookServiceImpl">
<property name="bookDao" ref="bookDao"/>
</bean>
<!--scope：为bean设置作用范围，可选值为单例singloton，非单例prototype-->
<bean id="bookDao" name="dao" class="com.itheima.dao.impl.BookDaoImpl"/>
2. bean作用范围scope配置
使用bean的scope属性可以控制bean的创建是否为单例：
singleton默认为单例prototype为非单例
3. bean的四种实例化方法
-
1.构造方法(常用)
-
2.工厂方式创建bean
1.创建方法，实现创建对象
public UserDao getUserDao(){
return new UserDaoImpl();
}
2.调用
UserDaoFactory userDaoFactory = new UserDaoFactory();
UserDao userDao = userDaoFactory.getUserDao();
userDao.save();
--------------------------------------------------------------------------
创建静态方法，实现创建对象
public static OrderDao getOrderDao(){
return new OrderDaoimpl();
}
调用静态方法实现
OrderDao orderDao = OrderDaoFactory.getOrderDao();
orderDao.save();
- 3.静态工厂实例化
1.创建静态方法，实现创建对象
public static OrderDao getOrderDao(){
return new OrderDaoimpl();
}
2.xml文件
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
class:工厂类的类全名
factory-mehod:具体工厂类中创建对象的方法名
3.调用
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
orderDao.save();
- 4.实例工厂实例化
ApplicationContext ctx = new
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) ctx.getBean("userDao");
userDao.save();
- 5.
FactoryBean
1.创建一个UserDaoFactoryBean的类，实现FactoryBean接口，重写接口的方法
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
//代替原始实例工厂中创建对象的方法
public UserDao getObject() throws Exception {
return new UserDaoImpl();
}
//返回所创建类的Class对象
public Class<?> getObjectType() {
return UserDao.class;
}
//单例还是多例
public boolean isSingleton() {
return false;
}
}
2.在Spring的配置文件中进行配置
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
3.使用
ApplicationContext ctx = new
ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) ctx.getBean("userDao");
userDao.save();
4. bean的生命周期
1.生命周期设置
- 1.第一种
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
- 2.第二种
添加两个接口InitializingBean，DisposableBean并实现接口中的两个方法afterPropertiesSet和destroy
2.注册钩子关闭容器
能够查看生命周期的执行
ctx.registerShutdownHook();
ClassPathXmlApplicationContextctx=new ClassPathXmlApplicationContext(“applicationContext.xml”);
注意:registerShutdownHook在ApplicationContext中也没有
- 初始化容器
- 1.创建对象(内存分配)
- 2.执行构造方法
- 3.执行属性注入(set操作)
- 4.执行bean初始化方法
- 使用bean
- 1.执行业务操作
- 关闭/销毁容器
- 1.执行bean销毁方法
2.DI
1.Setter方式注入
引用类型
1.在BookServiceImpl中声明userDao属性
private OrderDao orderDao;
2.为userDao属性提供setter方法
public void setOrderDao(OrderDao orderDao) {
this.orderDao = orderDao;
}
3.在配置文件中使用property标签注入
<bean id="orderdao" class="com.itheima.service.impl.OrderDaoimpl"></bean>
<bean id="Booksao" class="com.itheima.service.test.BookServiceImpl">
<property name="orderDao" ref="orderdao"></property>
</bean>
简单类型
同上面一样 只是在3不一样
<bean id="Booksao" class="com.itheima.service.test.BookServiceImpl">
<property name="name" value="wodeshijie"></property>
</bean>
2.构造器注入
跟Setter注入类似
引用类型
1.换成构造器
public BookServiceImpl(OrderDao orderDao) {
this.orderDao = orderDao;
}
2.在配置文件中使用property标签注入
<constructor-arg name="orderDao" ref="orderdao"></constructor-arg>
简单类型
如上相似
<constructor-arg name="named" value="wodeshij111ie"></constructor-arg>
3.自动装配
在<bean>标签中添加autowire属性
1.按照类型byType
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType"/>
注意
- 需要注入属性的类中对应属性的setter方法不能省略
- 被注入的对象必须要被Spring的IOC容器管理
- 按照类型在Spring的IOC容器中如果找到多个对象，会报
NoUniqueBeanDefinitionException
2.按照名字byName
<bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byName"/>
注意：
- 需要注入属性的类中对应属性的setter方法不能省略
- 所以按照名称注入，其实是和对应的set方法有关，但是如果按照标准起名称，属性名和set对应的名是一致的
总结:
最后对于依赖注入，需要注意一些其他的配置特征:
- 自动装配用于引用类型依赖注入，不能对简单类型进行操作
- 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用
- 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用
- 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效
4.集合注入
- 数组
- List
- Set
- Map
- Properties
`设置Ser方法`
private int[] array;
private List<String> list;
private Set<String> set;
private Map<String,String> map;
private Properties properties;
public void setList(List<String> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void setMap(Map<String, String> map) {
this.map = map;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
--------------------------------------------------------------------------
<bean id="Bookdao1" class="com.itheima.BookDao1Impl">
<property name="array"> //数组
<array>
<value>1</value>
<value>2</value>
<value>3</value>
</array>
</property>
<property name="list"> //列表
<list>
<value>itcast5</value>
<value>itheo</value>
</list>
</property>
<property name="set"> //set
<set>
<value>idfas</value>
<value>sd</value>
</set>
</property>
<property name="map"> //map
<map>
<entry key="country" value="china"></entry>
<entry key="province" value="henan"></entry>
<entry key="city" value="kaifeng"></entry>
</map>
</property>
<property name="properties"> //properties
<props>
<prop key="country">china</prop>
<prop key="province">henan</prop>
<prop key="city">kaifeng</prop>
</props>
</property>
说明：
- property标签表示setter方式注入，构造方式注入constructor-arg标签内部也可以写
<array>、<list>、<set>、<map>、<props>标签 - List的底层也是通过数组实现的，所以
<list>和<array>标签是可以混用 - 集合中要添加引用类型，只需要把
<value>标签改成<ref>标签，这种方式用的比较少
3.IOC/DI配置管理第三方bean
1.Druid管理和实现C3P0管理
实现方法基本类似
- 1.导入依赖
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.1.16</version>
</dependency>
- 2.配置第三方bean
<?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">
<!--管理DruidDataSource对象-->
<bean class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
</beans>
- 3.从IOC容器中获取对应的bean对象
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = (DataSource) ctx.getBean("dataSource");
System.out.println(dataSource);
}
}
注意:
- 数据连接池在配置属性的时候，除了可以注入数据库连接四要素外还可以配置很多其他的属性，具体都有哪些属性用到的时候再去查，一般配置基础的四个，其他都有自己的默认值
Druid和C3P0在没有导入mysql驱动包的前提下，一个没报错一个报错，说明Druid在初始化的时候没有去加载驱动，而C3P0刚好相反Druid程序运行虽然没有报错，但是当调用DruidDataSource的getConnection()方法获取连接的时候，也会报找不到驱动类的错误
2.加载properties文件
- 1.开启
context命名空间
- 2.加载properties配置文件
<context:property-placeholder location=“jdbc.properties”/>
- 3.resources下创建一个jdbc.properties文件,并添加对应的属性键值对
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root
- 4.完成属性注入
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
注意:
补充:--------方式五:不仅可以加载当前项目还可以加载当前项目所依赖的所有项目的根路径下的properties配置文件
4.核心容器
1.容器的创建方式
- 1.类路径下的XML配置文件
ApplicationContext ctx = new ClassPathXmlApplicationContext(“applicationContext.xml”);
- 2.文件系统下加载配置文件
ApplicationContext ctx = new FileSystemXmlApplicationContext(“F:\CodeJava\Spring_demo1\src\main\resources\applicationContext.xml”);
2.Bean的三种获取方式
- 1.DataSource boo = (DataSource) ctx.getBean(“boo”);
- 2.BookDao bookDao = ctx.getBean(“bookDao”，BookDao.class);
这种方式可以解决类型强转问题，但是参数又多加了一个，相对来说没有简化多少
- 3.BookDao bookDao = ctx.getBean(BookDao.class);
这种方式就类似我们之前所学习依赖注入中的按类型注入。必须要确保IOC容器中该类型对应的bean对象只能有一个。
3.容器类层次结构
(1)在IDEA中双击shift,输入BeanFactory
(2)点击进入BeanFactory类，ctrl+h,就能查看到如下结构的层次关系
4.总结
- 1.bean相关
- 2.依赖注入相关
3.容器相关 - BeanFactory是IoC容器的顶层接口，初始化BeanFactory对象时，加载的bean延迟加载
- ApplicationContext接口是Spring容器的核心接口，初始化时bean立即加载
- ApplicationContext接口提供基础的bean操作相关方法，通过其他接口扩展其功能
- ApplicationContext接口常用初始化类
- ClassPathXmlApplicationContext(常用)
- FileSystemXmlApplicationContext
5.IOC/DI注解开发
1.在BookDaoImpl类上添加 @Component注解
2.配置Spring的注解包扫描
<context:component-scan base-package=“com.itheima”/>
说明:
component-scan
- component:组件,Spring将管理的bean视作自己的一个组件
- scan:扫描
base-package指定Spring框架扫描的包路径，它会扫描指定包及其子包中的所有类上的注解。
- 包路径越多[如:com.itheima.dao.impl]，扫描的范围越小速度越快
- 包路径越少[如:com.itheima],扫描的范围越大速度越慢
- 一般扫描到项目的组织名称即Maven的groupId下[如:com.itheima]即可。
3.其中为了分辨业务层、逻辑层、数据层的注解bean
所以产生了三种 @Component/@Controller/@Service/@Repository
用法和component一样
1.纯注解开发
将配置文件applicationContext.xml删除掉，使用类来替换。
- 1.创建一个配置类
SpringConfig，Java类替换Spring核心配置文件
@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式
- 2.读取Spring核心配置文件初始化容器对象切换为读取Java配置类初始化容器对象
//加载配置类初始化容器
ApplicationContext ctx = new AnnotationConfigApplicationContext(springConfig.class);
BookDaooImpl dao = (BookDaooImpl) ctx.getBean("Boodao");
dao.save();
知识点1：@Configuration
知识点2：@ComponentScan
2.注解开发bean作用范围与生命周期管理
- 1.
Bean的作用范围
默认单例 非单例：prototype
@Controller("Boodao")
@Scope("prototype") ---->在这
public class BookDaooImpl {
public void save() {
System.out.println("book dao save。。。。。。");
}
}
- 2.
Bean的生命周期
只需要在对应的方法上添加@PostConstruct和@PreDestroy注解即可
@PostConstruct -------------------------->
public void init(){
System.out.println("destroy。。。。。");
}
@PreDestroy---------------------------->
public void Destory(){
System.out.println("init....");
}
注意:@PostConstruct和@PreDestroy注解如果找不到，需要导入下面的jar包
<dependency>
<groupId>javax.annotation</groupId>
<artifactId>javax.annotation-api</artifactId>
<version>1.3.2</version>
</dependency>
找不到的原因是，从JDK9以后jdk中的javax.annotation包被移除了，这两个注解刚好就在这个包中。
知识点1：@PostConstruct
知识点2：@PreDestroy
3.注解开发依赖注入 DI
知识点1：@Autowired
知识点2：@Qualifier
知识点3：@Value
知识点4：@PropertySource
4.IOC/DI注解开发管理第三方bean
1.首先在配置类中创建如下dataSource方法。
2.创建Druid的数据库连接池，用set方法进行数据的填入.
3.将其返回出来.
4.在其上加上@bean，让其交由spring进行管理.
加载这个第三方bean
1.将其放入配置类中，可以但是配置类内容特别多.
2.创建一个配置类JdbcConfig ，将数据加载进去，使用包进行扫描进去 ComponentScan,但是这种方法会使得引入过多的配置类，显得代码特别复杂。
3.最适合的方式，如下图中所示，使用Import进行导入.
注意: 注解开发实现为第三方bean注入资源
1.普通类型的注入还是用Value()
2.引用数据类型
-
1.在SpringConfig中扫描BookDao
-
2.在JdbcConfig类的方法上添加参数
知识点1：@Bean
知识点2：@Import
扫一扫
5万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
