本文介绍了Spring框架的基础概念，包括其作为轻量级容器的作用、IOC与AOP原理，以及软件设计六大原则等内容。同时详细讲解了Spring环境的搭建过程，包括依赖引入、配置文件编写、对象实例化管理等方面。
1 Spring 是什么？
针对Bean 生命周期进行管理的轻量级容器
IOC : 浅谈IOC--说清楚IOC是什么_ivan820819的博客-优快云博客_ioc
AOP (面向切面)
软件设计六大原则 : 设计模式六大原则
六大设计原则
1.开闭原则
定义：一个软件实体如类、模块和函数应该对扩展开放，对修改关闭
用抽象构建框架，用实现扩展细节
优点：提高软件系统的可复用性和可维护性
2.依赖倒置原则
- 定义：高层模块不应该依赖底层模块，二者都应该依赖其抽象
- 抽象不应该依赖细节；细节应该依赖抽象
- 针对接口编程，不要针对实现编程
- 优点：可以减少类间的耦合性、提高系统稳定性，提高代码可读性和可维护性，可降低修改程序所造成的风险
3单一职责原则
- 定义：不要存在多于一个导致类变更的原因
- 一个类/接口/方法只负责一项职责
- 优点：降低类的复杂度、提高类的可读性，提高系统的可维护性、降低变更引起的风险
4接口隔离原则
- 定义：用多个专门的接口，而不使用单一的总接口，客户端不应该依赖它不需要的接口
- 一个类对一个类的依赖应该建立在最小的接口上
- 建立单一接口，不要建立庞大臃肿的接口
- 尽量细化接口，接口中的方法尽量少
- 注意适度原则，一定要适度
- 优点：符合我们常说的高内聚低耦合的设计思想，从而使得类具有很好的可读性、可扩展性和可维护性
5迪米特法则（最少知道原则）
- 定义：一个对象应该对其他对象保持最少的了解，又叫最少知道原则
- 尽量降低类与类之间的耦合
- 优点：降低类之间的耦合
- 强调只和朋友交流，不和陌生人说话
- 朋友：出现在成员变量、方法的输入、输出参数中的类成为成员朋友类，而出现在方法内部的类不属于朋友类。
6里氏替换原则
定义：所有引用基类的地方必须能透明化地使用其子类的对象
即子类可以扩展父类的功能，但是不能改变父类原有的功能。也就是说，在子类继承父类的时候，除了添加新的方法完成新增功能之外，尽量不要重写父类的方法
子类可以实现父类的抽象方法，但是不能覆盖父类的非抽象方法
子类中可以增加自己特有的方法
当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更加宽松
什么是IOC
IOC是Inversion of Control的缩写，多数书籍翻译成“控制反转”。
对于面向对象设计及编程的基本思想，前面我们已经讲了很多了，不再赘述，简单来说就是把复杂系统分解成相互合作的对象，这些对象类通过封装以后，内部实现对外部是透明的，从而降低了解决问题的复杂度，而且可以灵活地被重用和扩展。
2 为什么使用Spring
- 方便解耦，简化开发
- Spring 就是一个大工厂，可以将所有对象创建和依赖关系维护，交给 Spring 管理
- 方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持
3.Spring环境搭建
引入spring的依赖
<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
<spring.version>4.2.5.RELEASE</spring.version>
</properties>
<!--Spring核心基础依赖-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${spring.version}</version>
</dependency>
<!--日志相关-->
<dependency>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.17</version>
</dependency>
<!--测试相关-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
添加配置文件
配置文件的名字可以任意设置,建议设置为applicationContext.xml，所以这里我们创建一个名为applicationContext.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">
</beans>
添加相应的模块
在项目中添加mapper 和数据交涉的文件、entity 实体类的包、service 具体业务逻辑的包
将bean的实例化交给Spring
<bean name="userDao" class="com.tledu.spring.dao.impl.UserDaoImpl" />
<!--name 属性名字/ref 引用的bean的名字-->
<bean id="userService" class="com.tledu.spring.service.UserService">
<property name="userDao" ref="userDao" />
</bean>
通过Set方法注入
<bean name="userDao" class="com.wxx.SpringDay01.mapper.IUserMapper" />
<!--name 属性名字/ref 引用的bean的名字-->
<bean id="userService" class="com.wxx.SpringDay01.service.impl.UserService">
<!-- //set方式注入-->
<!-- <property name="userDao" ref="userDao" />-->
<property name="lists">
<list>
<value>张三</value>
<value>李四</value>
<value>张武</value>
<value>王柳</value>
</list>
</property>
<property name="sets">
<set>
<value>1</value>
<value>2</value>
<value>3</value>
<value>3</value>
<value>4</value>
</set>
</property>
<property name="maps">
<map>
<entry key="1" value="法外狂徒张三"/>
<entry key="2" value="风暴快乐"/>
<entry key="3" value="法肉张三"/>
<entry key="1" value="法外狂徒2张三"/>
</map>
</property>// @Setter
IUserMapper userDao;
@Setter
List<String> lists;
@Setter
Set<Integer> sets;
@Setter
Map<Integer,String> maps;
通过构造方法注入
上面的程序可以看出,是通过set方法注入的对象,那么如何通过构造方法注入呢?
<!-- //构造器方式-->
<!-- <constructor-arg ref="userDao"/>--> public UserService(IUserMapper userDao) {
this.userDao = userDao;
}
public UserService() {
}生命周期
spring没有自己明确的生命周期
但是可以定义在每一个bean内，定义init和destroy方法
init-method
destroy-method
scope
spring中scope是一个非常关键的概念，简单说就是对象在spring容器（IOC容器）中的生命周期，也可以理解为对象在spring容器中的创建方式
<bean name="userDao" class="com.wxx.SpringDay01.mapper.IUserMapper" />
<!--name 属性名字/ref 引用的bean的名字-->
<bean id="userService" class="com.wxx.SpringDay01.service.impl.UserService" scope="prototype">singleton 单例模式
此取值时表明容器中创建时只存在一个实例，所有引用此bean都是单一实例。
也就是说创建对象是单例模式,并且如果不进行设置,默认就单例
prototype 多例模式
spring容器在进行输出prototype的bean对象 时，会每次都重新生成一个新的对象给请求方，虽然这种类型的对象的实例化以及属性设置等工作都是由容器负责的，但是只要准备完毕，并且对象实例返回给请求 方之后，容器就不在拥有当前对象的引用，请求方需要自己负责当前对象后继生命周期的管理工作，包括该对象的销毁。也就是说，容器每次返回请求方该对象的一 个新的实例之后，就由这个对象“自生自灭”，最典型的体现就是spring与struts2进行整合时，要把action的scope改为 prototype。
简单来说,就是每次获取都创建一个新对象,并且这个对象的生命周期不归Spring管理
自动装配
1 byName
byName是根据setter方法名字进行匹配,如果找不到,就不赋值
如 setUserDao 方法 就会找userDao,如果 bean的ID为 UserDao 也一样找不到,区分大小写
设置方式
IUserMapper userDao;
public void setUserDao(IUserMapper userDao) {
this.userDao = userDao;
}
名字可以自定义 只要Bean对的带上就行
<bean name="userDao" class="com.wxx.SpringDay01.mapper.IUserMapper" />
<!--name 属性名字/ref 引用的bean的名字-->
<bean id="userService" class="com.wxx.SpringDay01.service.impl.UserService" scope="prototype" autowire="byType">byType
byType是根据setter方法的参数列表中的数据类型进行匹配,如果beans.xml中出现了多个相同类型的对象,就会报错
迟加载
Spring容器默认是在执行
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
进行解析的时候创建对象并调用init,
如果我们不想让某个类在解析的时候就创建对象,而是用到的时候在创建对象的话,就需要设置迟加载
init-method="init" destroy-method="destroy" lazy-init="true"
我们可以在beans标签中添加default-lazy-init="true" 对所有的bean进行迟加载
<bean name="userDao" class="com.tledu.zrz.dao.impl.UserDaoImpl" >
<bean id="userService" class="com.tledu.zrz.service.UserService" scope="prototype"
autowire="byName" init-method="init" destroy-method="destroy" lazy-init="true" >
扫一扫
1319
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
