java 学习笔记指路
基础知识
前端
【黑马程序员pink老师前端】HTML
【黑马程序员pink老师前端】JavaScript基础大总结
【黑马程序员pink老师前端】JavaScript函数与作用域
【黑马程序员pink老师前端】JavaScript对象数据库
【黑马程序员数据库】数据库基础大总结
【黑马程序员数据库】数据库引擎
【黑马程序员数据库】数据库索引
【尚硅谷】索引优化分析
redis
数据库表设计
SQL编程
【牛客】SQL刷题篇入门篇
【牛客】SQL刷题篇进阶篇Java 框架
spring框架学习
Mybatis-plus 快速入门
Maven基础
Zookeeper初认识
HTTP简介
Tomcat
Servlet
vue入门
springcloud
springboot
springmvc
git
0. spring 入门须知
0.1 spring 的优点
为什么要用spring？
- 通过控制反转和依赖注入实现松耦合。
- 支持面向切面的编程，并且把应用业务逻辑和系统服务分开。通过切面和模板减少样板式代码。
- 声明事务的支持。可以从单调繁冗的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
- 方便集成各种优秀框架。内部提供了对各种优秀框架的直接支持（如：Hessian、Quartz、MyBatis等）。
- 方便程序的测试。Spring支持Junit4，添加注解便可以测试Spring程序。
spring里面我们主要学什么？
由他的优点可以看出来主要用到了：控制反转(IOC)，依赖注入(DI)，面相切面编程(AOP)
事务管理
集成其他框架
测试程序
0.2 spring 名词解释
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。
大白话解释就是尽可能多的封装，调用时使用接口，而不是重复写同一个函数。在新手看来其实很不容易理解，这样不太利于整体流程阅读，因为会无限次的调用，不过有个好处，便于维护，每次出现问题或者更新换代可以改动的少点。
工厂类就做到了一个提供接口(提供接口而不提供代码)的目的。简单一点理解，工厂类有点类似一个函数接口，通过传入不同的参数在工厂类内部区分成不通的对象，然后产生不通的对象实例，然后return给外面的人用。一个工厂类一般会提供一个函数接口(static的模式)来根据不同的参数返回不同的对象指针。
所以我理解似乎就是封装再封装？
1. 开发步骤
① 导spring包
② 编写 Dao 接口和实现类
③ 创建 Spring 核心配置文件
④ 在 Spring 配置文件中配置 UserDaoImpl
⑤ 使用 Spring 的 API 获得 Bean 实例
2. 配置bean文件
默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。
// 重点配置
<bean>标签
id属性:在容器中Bean实例的唯一标识，不允许重复
class属性:要实例化的Bean的全限定名
scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
<property>标签：属性注入
name属性：属性名称
value属性：注入的普通属性值
ref属性：注入的对象引用值
<list>标签
<map>标签
<properties>标签
<constructor-arg>标签
<import>标签:导入其他的Spring的分文件
2.1 基本属性
2.1.1 id：
Bean实例在Spring容器中的 唯一 标识（所以不能有重名）
2.1.2 class：
Bean的全限定名称（包名+类名）
2.1.3 scope：
指对象的作用范围，取值如下：
1.当scope的取值为singleton时
Bean的实例化个数：1个
Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
Bean的生命周期：
- 对象创建：当应用加载，创建容器时，对象就被创建了
- 对象运行：只要容器在，对象一直活着
- 对象销毁：当应用卸载，销毁容器时，对象就被销毁了
2.当scope的取值为prototype时
Bean的实例化个数：多个
Bean的实例化时机：当调用getBean()方法时实例化Bean
- 对象创建：当使用对象时，创建新的对象实例
- 对象运行：只要对象在使用中，就一直活着
- 对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了
2.1.4 生命周期
init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称
2.1.5 实例化三种方式
无参构造方法实例化
// 定义接口和类
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
工厂静态方法实例化
// 建立静态工厂类
public class StaticFactoryBean {
public static UserDao createUserDao(){
return new UserDaoImpl();
}
}
<bean id="userDao" class="com.itheima.factory.StaticFactoryBean"
factory-method="createUserDao" />
工厂实例方法实例化（非静态）
public class DynamicFactoryBean {
public UserDao createUserDao(){
return new UserDaoImpl();
}
}
<bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>
2.2 依赖注入(DI)
2.2.1 依赖注入是什么？
为了解耦，设置一种方法（比如set），在1接口实现类中使用2接口实现类定义的方法或数据。
- 普通数据类型
- 引用数据类型
- 集合数据类型
依赖注入方式：
set方法
构造方法
2.2.2 set依赖注入
2.2.2.1 引用注入
在UserServiceImpl（1接口实现类）中添加UserDao（2接口实现类）方法
实现类的写法：
set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .
public class UserServiceImpl implements UserService {
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void save() {
userDao.save();
}
}
xml配置文件的写法：
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<property name="userDao" ref="userDao"/>
</bean>
2.2.2.2 普通数据类型注入
public class UserDaoImpl implements UserDao {
private String company;
private int age;
public void setCompany(String company) {
this.company = company;
}
public void setAge(int age) {
this.age = age;
}
public void save() {
System.out.println(company+"==="+age);
System.out.println("UserDao save method running....");
}
}
xml文件配置
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<property name="company" value="传智播客"></property>
<property name="age" value="15"></property>
</bean>
2.2.2.3 List<String>
public class UserDaoImpl implements UserDao {
private List<String> strList;
public void setStrList(List<String> strList) {
this.strList = strList;
}
public void save() {
System.out.println(strList);
System.out.println("UserDao save method running....");
}
}
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<property name="strList">
<list>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</list>
</property>
</bean>
2.2.2.4 List<User>
public class UserDaoImpl implements UserDao {
private List<User> userList;
public void setUserList(List<User> userList) {
this.userList = userList;
}
public void save() {
System.out.println(userList);
System.out.println("UserDao save method running....");
}
}
<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<property name="userList">
<list>
<bean class="com.itheima.domain.User"/>
<bean class="com.itheima.domain.User"/>
<ref bean="u1"/>
<ref bean="u2"/>
</list>
</property>
</bean>
2.2.2.5 Map
public class UserDaoImpl implements UserDao {
private Map<String,User> userMap;
public void setUserMap(Map<String, User> userMap) {
this.userMap = userMap;
}
public void save() {
System.out.println(userMap);
System.out.println("UserDao save method running....");
}
}
<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<property name="userMap">
<map>
<entry key="user1" value-ref="u1"/>
<entry key="user2" value-ref="u2"/>
</map>
</property>
</bean>
2.2.2.6 Properties
public class UserDaoImpl implements UserDao {
private Properties properties;
public void setProperties(Properties properties) {
this.properties = properties;
}
public void save() {
System.out.println(properties);
System.out.println("UserDao save method running....");
}
}
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl">
<property name="properties">
<props>
<prop key="p1">aaa</prop>
<prop key="p2">bbb</prop>
<prop key="p3">ccc</prop>
</props>
</property>
</bean>
2.2.3 P命名空间注入（本质也是set）
引入P命名空间
xmlns:p="http://www.springframework.org/schema/p"
修改注入方式
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>
2.2.4 构造方法引用注入
创建有参构造
public class UserServiceImpl implements UserService {
@Override
public void save() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();
}
}
xml文件配置
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl">
<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>
2.2.5 拆解配置文件，分模块开发（import）
实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他
配置文件中，而在Spring主配置文件通过import标签进行加载
<import resource="applicationContext-xxx.xml"/>
3. 相关API
3.1 ApplicationContext的实现类
3.1.1 ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件 推荐使用这种
3.1.2 FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
3.1.3 AnnotationConfigApplicationContext
当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
3.2 getBean()方法
4. 配置数据源
5. 注解开发
注解代替xml配置，文件可以简化配置，提高开发效率。
| 注解 | 说明 |
|---|---|
| @Component | 在类上用于实例化Bean |
| @Controller | 在web层类上用于实例化Bean |
| @Service | 在service层类上用于实例化Bean |
| @Repository | 在dao层类上用于实例化Bean |
| @Autowired | 在字段上用于根据类型依赖注入 |
| @Qualifier | 结合@Autowired一起使用用于根据名称进行依赖注入 |
| @Resource | 相当于@Autowired+@Qualifier，按照名称进行注入 |
| @Value | 注入普通属性 |
| @Scope | 标注Bean的作用范围 |
| @PostConstruct | 在方法上标注该方法是Bean的初始化方法 |
| @PreDestroy | 在方法上标注该方法是Bean的销毁方法 |
| @Configuration | 指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解 |
| @ComponentScan | 用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的<context:component-scan base-package="com.itheima"/>一样 |
| @Bean | 使用在方法上，标注将该方法的返回值存储到 Spring 容器中 |
| @PropertySource | 用于加载.properties 文件中的配置 |
| @Import | 用于导入其他配置类 |
6. 整合Junit
6.1 原始Junit测试Spring的问题
在测试类中，每个测试方法都有以下两行代码：
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);
6.2 Spring集成Junit
- 让SpringJunit负责创建Spring容器，但是需要将配置文件的名称告诉它
- 将需要进行测试Bean直接在测试类中进行注入
6.2.1 Spring集成Junit步骤
① 导入spring集成Junit的坐标
② 使用@Runwith注解替换原来的运行期
③ 使用@ContextConfiguration指定配置文件或配置类
④ 使用@Autowired注入需要测试的对象
⑤ 创建测试方法进行测试
① 导入spring集成Junit的坐标
<!--此处需要注意的是，spring5 及以上版本要求 junit 的版本必须是 4.12 及以上--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.0.2.RELEASE</version>
</dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope>
</dependency>
② 使用@Runwith注解替换原来的运行期
@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {
}
③ 使用@ContextConfiguration指定配置文件或配置类
@RunWith(SpringJUnit4ClassRunner.class)
//加载spring核心配置文件
//@ContextConfiguration(value = {"classpath:applicationContext.xml"})
//加载spring核心配置类
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
}
④ 使用@Autowired注入需要测试的对象
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
@Autowired
private UserService userService; }
⑤ 创建测试方法进行测试
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
@Autowired
private UserService userService;
@Test
public void testUserService(){
userService.save();
} }
控制反转 IOC
IoC的底层实现原理是工厂设计模式+反射+XML配置文件，工厂设计模式就是定义一个工厂类
控制反转：
- 高等级的代码不能依赖低等级的代码；
- 抽象接口不能依赖具体实现；
高等级的代码，可以理解为抽象类、接口、装饰类等等；
低等级的代码，可以理解为抽象类的具体实现，定义具体功能的类；
- 控制反转是为了实现更灵活的依赖注入，而非消灭依赖注入；
- 当解决过度依赖，对具体类进行抽象的时候，便产生了Ioc，之后依赖注入的是抽象类。
- 控制反转解决代码的强耦合，增加了代码的可扩展性，这也就是为什么当今流行的框架Spring Boot和Laravel底层都是采用IoC；
依赖注入是IoC特性的一个重要功能，能自动将需要的Bean注入到对应的属性中，不需要手动进行初始化对象。
注入对象的方式主要有以下几种：
Set注入
构造器注入
本文主要讲解Spring依赖注入的基本类型及来源。
控制反转IOC是一种思想，其核心是将创建对象的权力和维护对象之间关系的权力交给第三方容器（比如Spring）。
依赖注入是实现控制反转思想的方法。
依赖注入（Dependency Injection）：通过注入的手段来维护对象与对象之间的依赖关系。
注入的方式有2种：set注入和构造方法注入。set注入是通过调用set方法来给属性赋值，构造方法注入即通过调用构造方法来给属性赋值
面相切面编程(AOP)
事务管理
集成其他框架
测试程序
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
