Spring学习笔记（狂神说）
1.Spring
1.1简介
Spring : 春天 --->给软件行业带来了春天mysql
2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。git
2004年3月24日，Spring框架以interface21框架为基础，通过从新设计，发布了1.0正式版。程序员
很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。github
Spring理念 : 使现有技术更加实用 . 自己就是一个大杂烩 , 整合现有的框架技术web
官网 : http://spring.io/spring
官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/sql
GitHub : https://github.com/spring-projects数据库
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
1.2优势
一、Spring是一个开源免费的框架 , 容器 .
二、Spring是一个轻量级的框架 , 非侵入式的 .
三、控制反转 IoC , 面向切面 Aop
四、对事物的支持 , 对框架的支持
.......
一句话归纳：
Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。
1.3组成
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了建立、配置和管理 bean 的方式 .
组成 Spring 框架的每一个模块（或组件）均可以单独存在，或者与其余一个或多个模块联合实现。每一个模块的功能以下：
- 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
- Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
- Spring AOP：经过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。因此，能够很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。经过使用 Spring AOP，不用依赖组件，就能够将声明性事务管理集成到应用程序中。
- Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不一样数据库供应商抛出的错误消息。异常层次结构简化了错误处理，而且极大地下降了须要编写的异常代码数量（例如打开和关闭链接）。Spring DAO 的面向 JDBC 的异常听从通用的 DAO 异常层次结构。
- Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。全部这些都听从 Spring 的通用事务和 DAO 异常层次结构。
- Spring Web 模块：Web 上下文模块创建在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。因此，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工做。
- Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。经过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
1.4拓展
Spring Boot与Spring Cloud
- Spring Boot 是 Spring 的一套快速配置脚手架，能够基于Spring Boot 快速开发单个微服务;
- Spring Cloud是基于Spring Boot实现的；
- Spring Boot专一于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
- Spring Boot使用了约束优于配置的理念，不少集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot能够离开Spring Cloud独立使用开发项目，可是Spring Cloud离不开Spring Boot，属于依赖的关系。
- SpringBoot在SpringClound中起到了承上启下的做用，若是你要学习SpringCloud必需要学习SpringBoot。
2.IoC基础
新建一个空白的maven项目
分析实现（代码）
咱们先用咱们原来的方式写一段代码 .
一、先写一个UserDao接口
public interface UserDao {
public void getUser();
}
二、再去写Dao的实现类
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("获取用户数据");
}
}
三、而后去写UserService的接口
public interface UserService {
public void getUser();
}
四、最后写Service的实现类
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
五、测试一下
@Test
public void test(){
UserService service = new UserServiceImpl();
service.getUser();
}
这是咱们原来的方式 , 开始你们也都是这么去写的对吧 . 那咱们如今修改一下 .
把Userdao的实现类增长一个 .
public class UserDaoMySqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("MySql获取用户数据");
}
}
紧接着咱们要去使用MySql的话 , 咱们就须要去service实现类里面修改对应的实现
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoMySqlImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
在假设, 咱们再增长一个Userdao的实现类 .
public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Oracle获取用户数据");
}
}
那么咱们要使用Oracle , 又须要去service实现类里面修改对应的实现 . 假设咱们的这种需求很是大 , 这种方式就根本不适用了, 甚至反人类对吧 , 每次变更 , 都须要修改大量代码 . 这种设计的耦合性过高了, 牵一发而动全身 .
那咱们如何去解决呢 ?
咱们能够在须要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 咱们去代码里修改下 .
public class UserServiceImpl implements UserService {
private UserDao userDao;
// 利用set实现
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
如今去咱们的测试类里 , 进行测试 ;
@Test
public void test(){
UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMySqlImpl() );
service.getUser();
//那咱们如今又想用Oracle去实现呢
service.setUserDao( new UserDaoOracleImpl() );
service.getUser();
}
- 以前是主动建立对象，控制权在程序员手上。
- 使用set以后，是被动接受对象。
你们发现了区别没有 ? 可能不少人说没啥区别 . 可是同窗们 , 他们已经发生了根本性的变化 , 不少地方都不同了 . 仔细去思考一下 , 之前全部东西都是由程序去进行控制建立 , 而如今是由咱们自行控制建立对象 , 把主动权交给了调用者 . 程序不用去管怎么建立,怎么实现了 . 它只负责提供一个接口 .
这种思想 , 从本质上解决了问题 , 咱们程序员再也不去管理对象的建立了 , 更多的去关注业务的实现 . 耦合性大大下降 . 这也就是IOC的原型 !
IOC本质
控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另外一种说法。没有IoC的程序中 , 咱们使用面向对象编程 , 对象的建立与对象间的依赖关系彻底硬编码在程序中，对象的建立由程序本身控制，控制反转后将对象的建立转移给第三方，我的认为所谓控制反转就是：得到依赖对象的方式反转了。
IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可使用XML配置，也可使用注解，新版本的Spring也能够零配置实现IoC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据建立与组织对象存入容器中，程序使用时再从Ioc容器中取出须要的对象。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式能够把二者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种经过描述（XML或注解）并经过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
3. Hello Spring
Hello代码
pojo中
package com.th.pojo;
public class Hello {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Hello{" +
"name='" + name + '\'' +
'}';
}
}
resource种
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!--bean = 对象-->
<!--id = 变量名-->
<!--class = new的对象-->
<!--property 至关于给对象中的属性设值-->
<bean id="hello" class="com.th.pojo.Hello">
<property name="name" value="Spring"/>
</bean>
</beans>
test
import com.th.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Mytest {
public static void main(String[] args) {
//获取spring上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//咱们的对象下能在都在spring·中管理了，咱们要使用，直接取出来就能够了
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
思考
- Hello 对象是谁建立的 ? 【hello 对象是由Spring建立的
- Hello 对象的属性是怎么设置的 ? hello 对象的属性是由Spring容器设置的
这个过程就叫控制反转 :
- 控制 : 谁来控制对象的建立 , 传统应用程序的对象是由程序自己控制建立的 , 使用Spring后 , 对象是由Spring来建立的
- 反转 : 程序自己不建立对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收
能够经过newClassPathXmlApplicationContext去浏览一下底层源码 .
修改案例一
咱们在案例一中， 新增一个Spring配置文件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="MysqlImpl" class="com.th.dao.impl.UserDaoMySqlImpl"/>
<bean id="OracleImpl" class="com.th.dao.impl.UserDaoOracleImpl"/>
<bean id="ServiceImpl" class="com.th.service.impl.UserServiceImpl">
<!--注意: 这里的name并非属性 , 而是UserServiceImpl中的一个dao的接口对象（例如 private UserDao userDao;）-->
<!--引用另一个bean , 不是用value 而是用 ref-->
<property name="userDao" ref="OracleImpl"/><!--具体使用哪一个接口这里能够直接配置-->
</bean>
</beans>
测试！
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserServiceImpl serviceImpl = (UserServiceImpl) context.getBean("ServiceImpl");//这里至关于将原来的Service层也IOC了，不须要再在代码中写出调用哪一个接口，只须要在配置文件中指明调用的接口便可。
serviceImpl.getUser();
//原来的步骤
//UserService userService = new UserServiceImpl();
//userService.setUserDao(new UserDaoMysqlImpl());//原先须要在代码中调用特定的方法
//userService.getUser();
}
OK , 到了如今 , 咱们完全不用再程序中去改动了 , 要实现不一样的操做 , 只须要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring 来建立 , 管理 , 装配 !
4. IOC建立对象的方式
4.1 使用无参构造建立对象，默认。
一、User.java
public class User {
private String name;
public User() {
System.out.println("user无参构造方法");
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+ name );
}
}
二、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="user" class="com.th.pojo.User">
<property name="name" value="他化"/>
</bean>
</beans>
三、测试类
<?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="user" class="com.th.pojo.User">
<property name="name" value="他化"/>
</bean>
</beans>
4.2使用有参构造
一、UserT . java
public class UserT {
private String name;
public UserT(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("name="+ name );
}
}
二、beans.xml 有三种方式编写
<!-- 第一种根据index参数下标设置 --> <bean id="userT" class="com.th.pojo.UserT"> <!-- index指构造方法 , 下标从0开始 --> <constructor-arg index="0" value="thshen2"/> </bean> <!-- 第二种根据参数名字设置 --> <bean id="userT" class="com.th.pojo.UserT"> <!-- name指参数名 --> <constructor-arg name="name" value="thshen2"/> </bean> <!-- 第三种根据参数类型设置(不推荐使用) --> <bean id="userT" class="com.th.pojo.UserT"> <constructor-arg type="java.lang.String" value="thshen2"/> </bean>
三、测试
@Test
public void testT(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserT user = (UserT) context.getBean("userT");
user.show();
}
结论：在配置文件加载的时候。其中管理的对象都已经初始化了！
5. Spring配置
5.1别名
alias 设置别名 , 为bean设置别名 , 能够设置多个别名
<!--设置别名：在获取Bean的时候可使用别名获取--> <alias name="userT" alias="userNew"/>
5.2Bean的配置
<!--bean就是java对象,由Spring建立和管理--> <!-- id 是bean的标识符,要惟一,若是没有配置id,name就是默认标识符 若是配置id,又配置了name,那么name是别名 name能够设置多个别名,能够用逗号,分号,空格隔开 若是不配置id和name,能够根据applicationContext.getBean(.class)获取对象; class是bean的全限定名=包名+类名 --> <bean id="hello" name="hello2 h2,h3;h4" class="com.th.pojo.Hello"> <property name="name" value="Spring"/> </bean>
import
通常用于团队开发，它能够将多个配置文件，导入合并为一个
<import resource="beans.xml"/>
6. DI依赖注入
6.1构造器注入
参考上面，已经说过
6.2 set方式注入（重点）
- 依赖：bean对象的建立依赖于容器
- 注入：bean对象中的全部属性，由容器来注入
【环境搭建】
- 复杂类型
- 真实测试对象
要求被注入的属性 , 必须有set方法 , set方法的方法名由set + 属性首字母大写 , 若是属性是boolean类型 , 没有set方法 , 是 is .
-
Address.java
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
-
Student.java
package com.th.pojo;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
public void setName(String name) {
this.name = name;
}
public void setAddress(Address address) {
this.address = address;
}
public void setBooks(String[] books) {
this.books = books;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public void setGames(Set<String> games) {
this.games = games;
}
public void setWife(String wife) {
this.wife = wife;
}
public void setInfo(Properties info) {
this.info = info;
}
public void show(){
System.out.println("name="+ name
+ ",address="+ address.getAddress()
+ ",books="
);
for (String book:books){
System.out.print("<<"+book+">>\t");
}
System.out.println("\n爱好:"+hobbys);
System.out.println("card:"+card);
System.out.println("games:"+games);
System.out.println("wife:"+wife);
System.out.println("info:"+info);
}
}
一、常量注入
<bean id="student" class="com.th.pojo.Student">
<property name="name" value="小明"/>
</bean>
测试：
@Test
public void test01(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
二、Bean注入
注意点：这里的值是一个引用，ref
<bean id="addr" class="com.th.pojo.Address">
<property name="address" value="重庆"/>
</bean>
<bean id="student" class="com.th.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
</bean>
三、数组注入
<bean id="student" class="com.th.pojo.Student">
<property name="name" value="小明"/>
<property name="address" ref="addr"/>
<property name="books">
<array>
<value>西游记</value>
<value>红楼梦</value>
<value>水浒传</value>
</array>
</property>
</bean>
四、List注入
<property name="hobbys">
<list>
<value>听歌</value>
<value>看电影</value>
<value>登山</value>
</list>
</property>
五、Map注入
<property name="card">
<map>
<entry key="中国邮政" value="456456456465456"/>
<entry key="建设" value="1456682255511"/>
</map>
</property>
六、set注入
<property name="games">
<set>
<value>LOL</value>
<value>BOB</value>
<value>COC</value>
</set>
</property>
七、Null注入
<property name="wife"><null/></property>
八、Properties注入
<property name="info">
<props>
<prop key="学号">20190604</prop>
<prop key="性别">男</prop>
<prop key="姓名">小明</prop>
</props>
</property>
测试结果：
6.3其余方式注入
p命名空间注入
User.java ：【注意：这里没有有参构造器！】
P命名空间注入 : 须要在头文件中加入约束文件
导入约束 : xmlns:p="http://www.springframework.org/schema/p" <!--P(属性: properties)命名空间 , 属性依然要设置set方法--> <bean id="user" class="com.th.pojo.User" p:name="狂神老师" p:age="18"/>
C命名空间注入
c 命名空间注入 : 须要在头文件中加入约束文件
导入约束 : xmlns:c="http://www.springframework.org/schema/c" <!--C(构造: Constructor)命名空间 , 属性依然要设置set方法--> <bean id="user" class="com.th.pojo.User" c:name="天魔" c:age="18"/>
发现问题：爆红了，刚才咱们没有写有参构造！
解决：把有参构造器加上，这里也能知道，c 就是所谓的构造器注入！
测试代码：
@Test
public void test02(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = (User) context.getBean("user");
System.out.println(user);
}
6.4 Bean的做用域
在Spring中，那些组成应用程序的主体及由Spring IoC容器所管理的对象，被称之为bean。简单地讲，bean就是由IoC容器初始化、装配及管理的对象 .
几种做用域中，request、session做用域仅在基于web的应用中使用（没必要关心你所采用的是什么web应用框架），只能用在基于web的Spring ApplicationContext环境。
Singleton
当一个bean的做用域为Singleton，那么Spring IoC容器中只会存在一个共享的bean实例，而且全部对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。Singleton是单例类型，就是在建立起容器时就同时自动建立了一个bean的对象，无论你是否使用，他都存在了，每次获取到的对象都是同一个对象。注意，Singleton做用域是Spring中的缺省做用域。要在XML中将bean定义成singleton，能够这样配置：
<bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">
单例模式也就是只new一次对象，以后getBean的都直接获取第一次new的对象
测试：
@Test
public void test03(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
User user = (User) context.getBean("user");
User user2 = (User) context.getBean("user2");//第二次getBean
System.out.println(user==user2);
}
Prototype
当一个bean的做用域为Prototype，表示一个bean定义对应多个对象实例。Prototype做用域的bean会致使在每次对该bean请求（将其注入到另外一个bean中，或者以程序的方式调用容器的getBean()方法）时都会建立一个新的bean实例。Prototype是原型类型，它在咱们建立容器的时候并无实例化，而是当咱们获取bean的时候才会去建立一个对象，并且咱们每次获取到的对象都不是同一个对象。根据经验，对有状态的bean应该使用prototype做用域，而对无状态的bean则应该使用singleton做用域。在XML中将bean定义成prototype，能够这样配置：
<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/> 或者 <bean id="account" class="com.foo.DefaultAccount" singleton="false"/>
-
原型模式也就是在以后的getBean时从新new一个对象
其他的request、session、application这些只能在web开放中使用！
7. Bean的自动装配
7.1自动装配说明。
- 自动装配是使用spring知足bean依赖的一种方法
- spring会在应用上下文中为某个bean寻找其依赖的bean。
在Spring中有三种装配的方式
-
在xml中显示配置
-
在java中显示配置
-
隐式的自动装配bean 【重要】
这里咱们主要讲第三种：自动化的装配bean。
Spring的自动装配须要从两个角度来实现，或者说是两个操做：
- 组件扫描(component scanning)：spring会自动发现应用上下文中所建立的bean；
- 自动装配(autowiring)：spring自动知足bean之间的依赖，也就是咱们说的IoC/DI；
组件扫描和自动装配组合发挥巨大威力，使得显示的配置下降到最少。
推荐不使用自动装配和xml配置 , 而使用注解 .
7.2测试坏境搭建
一、新建一个项目
二、新建两个实体类，Cat Dog 都有一个叫的方法
public class Cat {
public void shout() {
System.out.println("miao~");
}
}
public class Dog {
public void shout() {
System.out.println("wang~");
}
}
三、新建一个用户类 User
public class User {
private Cat cat;
private Dog dog;
private String str;
}
四、编写Spring配置文件
<?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="dog" class="com.th.pojo.Dog"/>
<bean id="cat" class="com.th.pojo.Cat"/>
<bean id="user" class="com.th.pojo.User">
<property name="cat" ref="cat"/>
<property name="dog" ref="dog"/>
<property name="str" value="他化"/>
</bean>
</beans>
五、测试
public class MyTest {
@Test
public void testMethodAutowire() {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
User user = (User) context.getBean("user");
user.getCat().shout();
user.getDog().shout();
}
}
结果正常输出，环境OK
7.3 byName
autowire byName (按名称自动装配)
因为在手动配置xml过程当中，经常发生字母缺漏和大小写等错误，而没法对其进行检查，使得开发效率下降。
采用自动装配将避免这些错误，而且使配置简单化。
测试：
一、修改bean配置，增长一个属性 autowire="byName"
<bean id="user" class="com.th.pojo.User" autowire="byName"> <property name="str" value="他化"/> </bean>
二、再次测试，结果依旧成功输出！
三、咱们将 cat 的bean id修改成 catXXX
四、再次测试， 执行时报空指针java.lang.NullPointerException。由于按byName规则找不对应set方法，真正的setCat就没执行，对象就没有初始化，因此调用时就会报空指针错误。
小结：
当一个bean节点带有 autowire byName的属性时。
- 将查找其类中全部的set方法名，例如setCat，得到将set去掉而且首字母小写的字符串，即cat。
- 去spring容器中寻找是否有此字符串名称id的对象。
- 若是有，就取出注入；若是没有，就报空指针异常。
7.4 byType
autowire byType (按类型自动装配)
使用autowire byType首先须要保证：同一类型的对象，在spring容器中惟一。若是不惟一，会报不惟一的异常。
NoUniqueBeanDefinitionException
测试：
一、将user的bean配置修改一下 ： autowire="byType"
二、测试，正常输出
三、在注册一个cat 的bean对象！
<bean id="dog" class="com.th.pojo.Dog"/> <bean id="cat" class="com.th.pojo.Cat"/> <bean id="cat2" class="com.th.pojo.Cat"/> <bean id="user" class="com.th.pojo.User" autowire="byType"> <property name="str" value="他化"/> </bean>
四、测试，报错：NoUniqueBeanDefinitionException
五、删掉cat2，将cat的bean名称改掉！测试！由于是按类型装配，因此并不会报异常，也不影响最后的结果。甚至将id属性去掉，也不影响结果。
这就是按照类型自动装配！
7.5 使用注解实现自动配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<context:annotation-config/>
</beans>
jdk1.5开始支持注解，spring2.5开始全面支持注解。
准备工做：利用注解的方式注入属性。
一、在spring配置文件中引入context文件头
xmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
二、开启属性注解支持！
<context:annotation-config/>
@Autowired
- @Autowired是按类型自动转配的，不支持id匹配。
- 须要导入 spring-aop的包！
测试：
一、将User类中的set方法去掉，使用@Autowired注解
public class User {
@Autowired
private Cat cat;
@Autowired
private Dog dog;
private String str;
public Cat getCat() {
return cat;
}
public Dog getDog() {
return dog;
}
public String getStr() {
return str;
}
}
二、此时配置文件内容
<context:annotation-config/> <bean id="dog" class="com.th.pojo.Dog"/> <bean id="cat" class="com.th.pojo.Cat"/> <bean id="user" class="com.th.pojo.User"/>
三、测试，成功输出结果！
【小狂神科普时间】
@Autowired(required=false) 说明：false，对象能够为null；true，对象必须存对象，不能为null。
//若是容许对象为null，设置required = false,默认为true @Autowired(required = false) private Cat cat;
@Qualifier
- @Autowired是根据类型自动装配的，加上@Qualifier则能够根据byName的方式自动装配
- @Qualifier不能单独使用。
测试实验步骤：
一、配置文件修改内容，保证类型存在对象。且名字不为类的默认名字！
<bean id="dog1" class="com.th.pojo.Dog"/> <bean id="dog2" class="com.th.pojo.Dog"/> <bean id="cat1" class="com.th.pojo.Cat"/> <bean id="cat2" class="com.th.pojo.Cat"/>
二、没有加Qualifier测试，直接报错
三、在属性上添加Qualifier注解
@Autowired @Qualifier(value = "cat2") private Cat cat; @Autowired @Qualifier(value = "dog2") private Dog dog;
测试，成功输出！
@Resource
- @Resource若有指定的name属性，先按该属性进行byName方式查找装配；
- 其次再进行默认的byName方式进行装配；
- 若是以上都不成功，则按byType的方式自动装配。
- 都不成功，则报异常。
实体类：
public class User {
//若是容许对象为null，设置required = false,默认为true
@Resource(name = "cat2")
private Cat cat;
@Resource
private Dog dog;
private String str;
}
beans.xml
<bean id="dog" class="com.th.pojo.Dog"/> <bean id="cat1" class="com.th.pojo.Cat"/> <bean id="cat2" class="com.th.pojo.Cat"/> <bean id="user" class="com.th.pojo.User"/>
测试：结果OK
配置文件2：beans.xml ， 删掉cat2
<bean id="dog" class="com.th.pojo.Dog"/> <bean id="cat1" class="com.th.pojo.Cat"/>
实体类上只保留注解
@Resource private Cat cat; @Resource private Dog dog;
结果：OK
结论：先进行byType查找，失败；再进行byName查找，成功。
小节
@Autowired与@Resource异同：
一、@Autowired与@Resource均可以用来装配bean。均可以写在字段上，或写在setter方法上。
二、@Autowired默认按类型装配（属于spring规范），默认状况下必需要求依赖对象必须存在，若是要容许null 值，能够设置它的required属性为false，如：@Autowired(required=false) ，若是咱们想使用名称装配能够结合@Qualifier注解进行使用
三、@Resource（属于J2EE复返），默认按照名称进行装配，名称能够经过name属性进行指定。若是没有指定name属性，当注解写在字段上时，默认取字段名进行按照名称查找，若是注解写在setter方法上默认取属性名进行装配。当找不到与名称匹配的bean时才按照类型进行装配。可是须要注意的是，若是name属性一旦指定，就只会按照名称进行装配。
它们的做用相同都是用注解方式注入对象，但执行顺序不一样。@Autowired先byType，@Resource先byName。
8. 使用注解开发
8.1说明
在spring4以后，必需要保证aop的包导入
使t用注解须要导入context的约束
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
</beans>
8.2 Bean的实现
咱们以前都是使用 bean 的标签进行bean注入，可是实际开发中，咱们通常都会使用注解！
一、配置扫描哪些包下的注解
<!--指定注解扫描包--> <context:component-scan base-package="com.th.pojo"/>
二、在指定包下编写类，增长注解
@Component("user")
// 至关于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
public String name = "秦疆";
}
三、测试
@Test
public void test(){
ApplicationContext applicationContext =
new ClassPathXmlApplicationContext("beans.xml");
User user = (User) applicationContext.getBean("user");
System.out.println(user.name);
}
8.三、属性注入
使用注解注入属性
一、能够不用提供set方法，直接在直接名上添加@value("值")
@Component("user")
// 至关于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
@Value("秦疆")
// 至关于配置文件中 <property name="name" value="秦疆"/>
public String name;
}
二、若是提供了set方法，在set方法上添加@value("值");
@Component("user")
public class User {
public String name;
@Value("秦疆")
public void setName(String name) {
this.name = name;
}
}
8.四、衍生注解
咱们这些注解，就是替代了在配置文件当中配置步骤而已！更加的方便快捷！
@Component三个衍生注解
为了更好的进行分层，Spring可使用其它三个注解，功能同样，目前使用哪个功能都同样。
- @Controller：web层
- @Service：service层
- @Repository：dao层
写上这些注解，就至关于将这个类交给Spring管理装配了！
8.五、自动装配注解
在Bean的自动装配已经讲过了，能够回顾！
8.六、做用域
@scope
- singleton：默认的，Spring会采用单例模式建立这个对象。关闭工厂 ，全部的对象都会销毁。
- prototype：多例模式。关闭工厂 ，全部的对象不会销毁。内部的垃圾回收机制会回收
@Controller("user")
@Scope("prototype")
public class User {
@Value("秦疆")
public String name;
}
8.七、小结
XML与注解比较
- XML能够适用任何场景 ，结构清晰，维护方便
- 注解不是本身提供的类使用不了，开发简单方便
xml与注解整合开发 ：推荐最佳实践
- xml管理Bean
- 注解完成属性注入
- 使用过程当中， 能够不用扫描，扫描是为了类上的注解
<context:annotation-config/>
做用：
- 进行注解驱动注册，从而使注解生效
- 用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
- 若是不扫描包，就须要手动配置bean
- 若是不加注解驱动，则注入的值为null！
9. 使用java方式配置spring
彻底不使用xml配置
JavaConfig 原来是 Spring 的一个子项目，它经过 Java 类的方式提供 Bean 的定义信息，在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能 。
测试：
一、编写一个实体类，Dog
@Component //将这个类标注为Spring的一个组件，放到容器中！
public class Dog {
public String name = "dog";
}
二、新建一个config配置包，编写一个MyConfig配置类
@Configuration //表明这是一个配置类
public class MyConfig {
@Bean //经过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
public Dog dog(){
return new Dog();
}
}
三、测试
@Test
public void test2(){
ApplicationContext applicationContext =
new AnnotationConfigApplicationContext(MyConfig.class);
Dog dog = (Dog) applicationContext.getBean("dog");
System.out.println(dog.name);
}
四、成功输出结果！
导入其余配置如何作呢？
一、咱们再编写一个配置类！
@Configuration //表明这是一个配置类
public class MyConfig2 {
}
二、在以前的配置类中咱们来选择导入这个配置类
@Configuration
@Import(MyConfig2.class) //导入合并其余配置类，相似于配置文件中的 inculde 标签
public class MyConfig {
@Bean
public Dog dog(){
return new Dog();
}
}
关于这种Java类的配置方式，咱们在以后的SpringBoot 和 SpringCloud中还会大量看到，咱们须要知道这些注解的做用便可！
10. 动态代理
为何要学习代理模式，由于AOP的底层机制就是动态代理！【SpringAOP和SpringMVC】
代理模式：
- 静态代理
- 动态代理
学习aop以前 , 咱们要先了解一下代理模式！
10.一、静态代理
静态代理角色分析
- 抽象角色 : 通常使用接口或者抽象类来实现
- 真实角色 : 被代理的角色
- 代理角色 : 代理真实角色 ; 代理真实角色后 , 通常会作一些附属的操做 .
- 客户 : 使用代理角色来进行一些操做 .
代码实现
Rent . java 即抽象角色
//抽象角色：租房
public interface Rent {
public void rent();
}
Host . java 即真实角色
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
public void rent() {
System.out.println("房屋出租");
}
}
Proxy . java 即代理角色
//代理角色：中介
public class Proxy implements Rent {
private Host host;
public Proxy() { }
public Proxy(Host host) {
this.host = host;
}
//租房
public void rent(){
seeHouse();
host.rent();
fare();
}
//看房
public void seeHouse(){
System.out.println("带房客看房");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}
Client . java 即客户
//客户类，通常客户都会去找代理！
public class Client {
public static void main(String[] args) {
//房东要租房
Host host = new Host();
//中介帮助房东
Proxy proxy = new Proxy(host);
//你去找中介！
proxy.rent();
}
}
分析：在这个过程当中，你直接接触的就是中介，就如同现实生活中的样子，你看不到房东，可是你依旧租到了房东的房子经过代理，这就是所谓的代理模式，程序源自于生活，因此学编程的人，通常可以更加抽象的看待生活中发生的事情。
静态代理的好处:
- 可使得咱们的真实角色更加纯粹 . 再也不去关注一些公共的事情 .
- 公共的业务由代理来完成 . 实现了业务的分工 ,
- 公共业务发生扩展时变得更加集中和方便 .
缺点 :
- 类多了 , 多了代理类 , 工做量变大了 . 开发效率下降 .
咱们想要静态代理的好处，又不想要静态代理的缺点，因此 , 就有了动态代理 !
10.2 加深理解
同窗们练习完毕后，咱们再来举一个例子，巩固你们的学习！
练习步骤：
一、建立一个抽象角色，好比咋们平时作的用户业务，抽象起来就是增删改查！
//抽象角色：增删改查业务
public interface UserService {
void add();
void delete();
void update();
void query();
}
二、咱们须要一个真实对象来完成这些增删改查操做
//真实对象，完成增删改查操做的人
public class UserServiceImpl implements UserService {
public void add() {
System.out.println("增长了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("更新了一个用户");
}
public void query() {
System.out.println("查询了一个用户");
}
}
三、需求来了，如今咱们须要增长一个日志功能，怎么实现！
- 思路1 ：在实现类上增长代码 【麻烦！】
- 思路2：使用代理来作，可以不改变原来的业务状况下，实现此功能就是最好的了！
四、设置一个代理类来处理日志！代理角色
//代理角色，在这里面增长日志的实现
public class UserServiceProxy implements UserService {
private UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
public void add() {
log("add");
userService.add();
}
public void delete() {
log("delete");
userService.delete();
}
public void update() {
log("update");
userService.update();
}
public void query() {
log("query");
userService.query();
}
public void log(String msg){
System.out.println("执行了"+msg+"方法");
}
}
五、测试访问类：
public class Client {
public static void main(String[] args) {
//真实业务
UserServiceImpl userService = new UserServiceImpl();
//代理类
UserServiceProxy proxy = new UserServiceProxy();
//使用代理类实现日志功能！
proxy.setUserService(userService);
proxy.add();
}
}
OK，到了如今代理模式你们应该都没有什么问题了，重点你们须要理解其中的思想；
咱们在不改变原来的代码的状况下，实现了对原有功能的加强，这是AOP中最核心的思想
聊聊AOP：纵向开发，横向开发
10.三、动态代理
- 动态代理的角色和静态代理的同样 .
- 动态代理的代理类是动态生成的 . 静态代理的代理类是咱们提早写好的
- 动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
-
- 基于接口的动态代理----JDK动态代理
- 基于类的动态代理--cglib
- 如今用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
- 咱们这里使用JDK的原生代码来实现，其他的道理都是同样的！、
JDK的动态代理须要了解两个类
核心 : InvocationHandler 和 Proxy ， 打开JDK帮助文档看看
【InvocationHandler：调用处理程序】
Object invoke(Object proxy, 方法 method, Object[] args)； //参数 //proxy - 调用该方法的代理实例 //method -所述方法对应于调用代理实例上的接口方法的实例。方法对象的声明类将是该方法声明的接口，它能够是代理类继承该方法的代理接口的超级接口。 //args -包含的方法调用传递代理实例的参数值的对象的阵列，或null若是接口方法没有参数。原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。
【Proxy : 代理】
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
代码实现
抽象角色和真实角色和以前的同样！
Rent . java 即抽象角色
//抽象角色：租房
public interface Rent {
public void rent();
}
Host . java 即真实角色j
//真实角色: 房东，房东要出租房子
public class Host implements Rent{
public void rent() {
System.out.println("房屋出租");
}
}
ProxyInvocationHandler. java 即代理角色
public class ProxyInvocationHandler implements InvocationHandler {
private Rent rent;
public void setRent(Rent rent) {
this.rent = rent;
}
//生成代理类，重点是第二个参数，获取要代理的抽象角色！以前都是一个角色，如今能够代理一类角色
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(),this);
}
// proxy : 代理类 method : 代理类的调用处理程序的方法对象.
// 处理代理实例上的方法调用并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
seeHouse();
//核心：本质利用反射实现！
Object result = method.invoke(rent, args);
fare();
return result;
}
//看房
public void seeHouse(){
System.out.println("带房客看房");
}
//收中介费
public void fare(){
System.out.println("收中介费");
}
}
Client . java
//租客
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理实例的调用处理程序
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setRent(host); //将真实角色放置进去！
Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
proxy.rent();
}
}
核心：一个动态代理 , 通常代理某一类业务 , 一个动态代理能够代理多个类，代理的是接口！、
10.4深化理解
咱们来使用动态代理实现代理咱们后面写的UserService！
咱们也能够编写一个通用的动态代理实现的类！全部的代理对象设置为Object便可！
public class ProxyInvocationHandler implements InvocationHandler {
private Object target;
public void setTarget(Object target) {
this.target = target;
}
//生成代理类
public Object getProxy(){
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
target.getClass().getInterfaces(),this);
}
// proxy : 代理类
// method : 代理类的调用处理程序的方法对象.
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
Object result = method.invoke(target, args);
return result;
}
public void log(String methodName){
System.out.println("执行了"+methodName+"方法");
}
}
测试！
public class Test {
public static void main(String[] args) {
//真实对象
UserServiceImpl userService = new UserServiceImpl();
//代理对象的调用处理程序
ProxyInvocationHandler pih = new ProxyInvocationHandler();
pih.setTarget(userService); //设置要代理的对象
UserService proxy = (UserService)pih.getProxy(); //动态生成代理类！
proxy.delete();
}
}
测试，增删改查，查看结果！
动态代理的好处
静态代理有的它都有，静态代理没有的，它也有！
- 可使得咱们的真实角色更加纯粹 . 再也不去关注一些公共的事情 .
- 公共的业务由代理来完成 . 实现了业务的分工 ,
- 公共业务发生扩展时变得更加集中和方便 .
- 一个动态代理 , 通常代理某一类业务
- 一个动态代理能够代理多个类，代理的是接口！
11.AOP
那咱们接下来就来聊聊AOP吧！
11.一、什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，经过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP能够对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度下降，提升程序的可重用性，同时提升了开发的效率。
11.二、Aop在Spring中的做用
提供声明式事务；容许用户自定义切面
如下名词须要了解下：
- 横切关注点：跨越应用程序多个模块的方法或功能。便是，与咱们业务逻辑无关的，可是咱们须要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 ....
- 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
- 通知（Advice）：切面必需要完成的工做。即，它是类中的一个方法。
- 目标（Target）：被通知对象。
- 代理（Proxy）：向目标对象应用通知以后建立的对象。
- 切入点（PointCut）：切面通知 执行的 “地点”的定义。
- 链接点（JointPoint）：与切入点匹配的执行点。
SpringAOP中，经过Advice定义横切逻辑，Spring中支持5种类型的Advice:
即 Aop 在 不改变原有代码的状况下 , 去增长新的功能 .
11.三、使用Spring实现Aop
【重点】使用AOP织入，须要导入一个依赖包！
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency>
第一种方式
1.经过 Spring API 实现
首先编写咱们的业务接口和实现类
public interface UserService {
public void add();
public void delete();
public void update();
public void search();
}
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增长用户");
}
@Override
public void delete() {
System.out.println("删除用户");
}
@Override
public void update() {
System.out.println("更新用户");
}
@Override
public void search() {
System.out.println("查询用户");
}
}
而后去写咱们的加强类 , 咱们编写两个 , 一个前置加强 一个后置加强
public class Log implements MethodBeforeAdvice {
//method : 要执行的目标对象的方法
//objects : 被调用的方法的参数
//Object : 目标对象
@Override
public void before(Method method, Object[] objects, Object o) throws Throwable {
System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被执行了");
}
}
public class AfterLog implements AfterReturningAdvice {
//returnValue 返回值
//method被调用的方法
//args 被调用的方法的对象的参数
//target 被调用的目标对象
@Override
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了" + target.getClass().getName()
+"的"+method.getName()+"方法,"
+"返回值："+returnValue);
}
}
最后去spring的文件中注册 , 并实现aop切入实现 , 注意导入约束 .
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">
<!--注册bean-->
<bean id="userService" class="com.th.service.UserServiceImpl"/>
<bean id="log" class="com.th.log.Log"/>
<bean id="afterLog" class="com.th.log.AfterLog"/>
<!--aop的配置-->
<aop:config>
<!--切入点 expression:表达式匹配要执行的方法-->
<aop:pointcut id="pointcut" expression="execution(* com.th.service.UserServiceImpl.*(..))"/>
<!--执行环绕; advice-ref执行方法 . pointcut-ref切入点-->
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
</aop:config>
</beans>
测试
public class MyTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService) context.getBean("userService");
userService.search();
}
}
Aop的重要性 : 很重要 . 必定要理解其中的思路 , 主要是思想的理解这一块 .
Spring的Aop就是将公共的业务 (日志 , 安全等) 和领域业务结合起来 , 当执行领域业务时 , 将会把公共业务加进来 . 实现公共业务的重复利用 . 领域业务更纯粹 , 程序猿专一领域业务 , 其本质仍是动态代理 .
第二种方式
2.自定义类来实现Aop
目标业务类不变依旧是userServiceImpl
第一步 : 写咱们本身的一个切入类
public class DiyPointcut {
public void before(){
System.out.println("---------方法执行前---------");
}
public void after(){
System.out.println("---------方法执行后---------");
}
}
去spring中配置
<!--第二种方式自定义实现-->
<!--注册bean-->
<bean id="diy" class="com.th.config.DiyPointcut"/>
<!--aop的配置-->
<aop:config>
<!--第二种方式：使用AOP的标签实现-->
<aop:aspect ref="diy">
<aop:pointcut id="diyPonitcut" expression="execution(* com.th.service.UserServiceImpl.*(..))"/>
<aop:before pointcut-ref="diyPonitcut" method="before"/>
<aop:after pointcut-ref="diyPonitcut" method="after"/>
</aop:aspect>
</aop:config>
测试：
public class MyTest {
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
UserService userService = (UserService) context.getBean("userService");
userService.add();
}
}
第三种方式
3.使用注解实现
第一步：编写一个注解实现的加强类
package com.th.config;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect
public class AnnotationPointcut {
@Before("execution(* com.th.service.UserServiceImpl.*(..))")
public void before(){
System.out.println("---------方法执行前---------");
}
@After("execution(* com.th.service.UserServiceImpl.*(..))")
public void after(){
System.out.println("---------方法执行后---------");
}
@Around("execution(* com.th.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
System.out.println("签名:"+jp.getSignature());
//执行目标方法proceed
Object proceed = jp.proceed();
System.out.println("环绕后");
System.out.println(proceed);
}
}
第二步：在Spring配置文件中，注册bean，并增长支持注解的配置
<!--第三种方式:注解实现--> <bean id="annotationPointcut" class="com.th.config.AnnotationPointcut"/> <aop:aspectj-autoproxy/>
aop:aspectj-autoproxy：说明
经过aop命名空间的<aop:aspectj-autoproxy />声明自动为spring容器中那些配置@aspectJ切面的bean建立代理，织入切面。固然，spring 在内部依旧采用AnnotationAwareAspectJAutoProxyCreator进行自动代理的建立工做，但具体实现的细节已经被<aop:aspectj-autoproxy />隐藏起来了 <aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入加强，当配为<aop:aspectj-autoproxy poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入加强。不过即便proxy-target-class设置为false，若是目标类没有声明接口，则spring将自动使用CGLib动态代理。
到了这里，AOP的思想和使用相信你们就没问题了！
12. 整合mybatis
依赖
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-study</artifactId>
<groupId>com.hou</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>spring-10-mybatis</artifactId>
<dependencies>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>2.0.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>5.2.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.9.4</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.12</version>
</dependency>
</dependencies>
<build>
<resources>
<resource>
<directory>src/main/resources</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
</resource>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
</project>
12.1步骤
一、导入相关jar包
junit
<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> </dependency>
mybatis
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.2</version> </dependency>
mysql-connector-javax
<dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>5.1.47</version> </dependency>
spring相关
<dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.1.10.RELEASE</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>5.1.10.RELEASE</version> </dependency>
aspectJ AOP 织入器
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver --> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency>
mybatis-spring整合包 【重点】
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.2</version> </dependency>
配置Maven静态资源过滤问题！
<build>
<resources>
<resource>
<directory>src/main/java</directory>
<includes>
<include>**/*.properties</include>
<include>**/*.xml</include>
</includes>
<filtering>true</filtering>
</resource>
</resources>
</build>
二、编写配置文件
三、代码实现
12.2 回忆MyBatis
编写pojo实体类
package com.th.pojo;
public class User {
private int id; //id
private String name; //姓名
private String pwd; //密码
}
实现mybatis的配置文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.th.pojo"/>
</typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</dataSource>
</environment>
</environments>
<mappers>
<package name="com.th.dao"/>
</mappers>
</configuration>
UserDao接口编写
public interface UserMapper {
public List<User> selectUser();
}
接口对应的Mapper映射文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.th.dao.UserMapper">
<select id="selectUser" resultType="User">
select * from user
</select>
</mapper>
测试类
@Test
public void selectUser() throws IOException {
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
for (User user: userList){
System.out.println(user);
}
sqlSession.close();
}
12.三、MyBatis-Spring学习
引入Spring以前须要了解mybatis-spring包中的一些重要类；
文档 ：http://www.mybatis.org/spring/zh/index.html
什么是 MyBatis-Spring？
MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。
知识基础
在开始使用 MyBatis-Spring 以前，你须要先熟悉 Spring 和 MyBatis 这两个框架和有关它们的术语。这很重要
MyBatis-Spring 须要如下版本：
| MyBatis-Spring | MyBatis | Spring 框架 | Spring Batch | Java |
|---|---|---|---|---|
| 2.0 | 3.5+ | 5.0+ | 4.0+ | Java 8+ |
| 1.3 | 3.4+ | 3.2.2+ | 2.1+ | Java 6+ |
若是使用 Maven 做为构建工具，仅须要在 pom.xml 中加入如下代码便可：
<dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>2.0.2</version> </dependency>
要和 Spring 一块儿使用 MyBatis，须要在 Spring 应用上下文中定义至少两样东西：一个 SqlSessionFactory 和至少一个数据映射器类。
在 MyBatis-Spring 中，可以使用SqlSessionFactoryBean来建立 SqlSessionFactory。要配置这个工厂 bean，只须要把下面代码放在 Spring 的 XML 配置文件中：
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource" /> </bean>
注意：SqlSessionFactory须要一个 DataSource（数据源）。这能够是任意的 DataSource，只须要和配置其它 Spring 数据库链接同样配置它就能够了。
在基础的 MyBatis 用法中，是经过 SqlSessionFactoryBuilder 来建立 SqlSessionFactory 的。而在 MyBatis-Spring 中，则使用 SqlSessionFactoryBean 来建立。
在 MyBatis 中，你可使用 SqlSessionFactory 来建立 SqlSession。一旦你得到一个 session 以后，你可使用它来执行映射了的语句，提交或回滚链接，最后，当再也不须要它的时候，你能够关闭 session。
SqlSessionFactory有一个惟一的必要属性：用于 JDBC 的 DataSource。这能够是任意的 DataSource 对象，它的配置方法和其它 Spring 数据库链接是同样的。
一个经常使用的属性是 configLocation，它用来指定 MyBatis 的 XML 配置文件路径。它在须要修改 MyBatis 的基础配置很是有用。一般，基础配置指的是 < settings> 或 < typeAliases>元素。
须要注意的是，这个配置文件并不须要是一个完整的 MyBatis 配置。确切地说，任何环境配置（），数据源（）和 MyBatis 的事务管理器（）都会被忽略。SqlSessionFactoryBean 会建立它自有的 MyBatis 环境配置（Environment），并按要求设置自定义环境的值。
SqlSessionTemplate 是 MyBatis-Spring 的核心。做为 SqlSession 的一个实现，这意味着可使用它无缝代替你代码中已经在使用的 SqlSession。
模板能够参与到 Spring 的事务管理中，而且因为其是线程安全的，能够供多个映射器类使用，你应该老是用 SqlSessionTemplate 来替换 MyBatis 默认的 DefaultSqlSession 实现。在同一应用程序中的不一样类之间混杂使用可能会引发数据一致性的问题。
可使用 SqlSessionFactory 做为构造方法的参数来建立 SqlSessionTemplate 对象。
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <constructor-arg index="0" ref="sqlSessionFactory" /> </bean>
如今，这个 bean 就能够直接注入到你的 DAO bean 中了。你须要在你的 bean 中添加一个 SqlSession 属性，就像下面这样：
public class UserDaoImpl implements UserDao {
private SqlSession sqlSession;
public void setSqlSession(SqlSession sqlSession) {
this.sqlSession = sqlSession;
}
public User getUser(String userId) {
return sqlSession.getMapper...;
}
按下面这样，注入 SqlSessionTemplate：
<bean id="userDao" class="org.mybatis.spring.sample.dao.UserDaoImpl"> <property name="sqlSession" ref="sqlSession" /> </bean>
12.4整合实现一
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<!--data source-->
<!--配置数据源：数据源有很是多，可使用第三方的，也可以使使用Spring的-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!--sqlsession-->
<!--配置SqlSessionFactory-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource" />
<!--关联Mybatis-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/th/dao/*.xml"/>
</bean>
<!--注册sqlSessionTemplate , 关联sqlSessionFactory-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<!--利用构造器注入-->
<constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>
<bean id="userDao" class="com.th.dao.UserDaoImpl">
<property name="sqlSession" ref="sqlSession"/>
</bean>
</beans>
一、引入Spring配置文件Spring-dao.xml（名字随便起）最后导入到applicationContext.xml 测试中就能够直接这个applicationContext.xml
二、配置数据源替换mybaits的数据源
三、配置SqlSessionFactory，关联MyBatis
四、注册sqlSessionTemplate，关联sqlSessionFactory；
五、增长Dao接口的实现类；私有化sqlSessionTemplate
public class UserDaoImpl implements UserMapper {
//sqlSession不用咱们本身建立了，Spring来管理
private SqlSessionTemplate sqlSession;
public void setSqlSession(SqlSessionTemplate sqlSession) {
this.sqlSession = sqlSession;
}
public List<User> selectUser() {
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
return mapper.selectUser();
}
}
六、注册bean实现
<bean id="userDao" class="com.th.dao.UserDaoImpl"> <property name="sqlSession" ref="sqlSession"/> </bean>
七、测试
先applicationContext.xml中导入一下
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper mapper = (UserMapper) context.getBean("userDao");
List<User> user = mapper.selectUser();
System.out.println(user);
}
结果成功输出！如今咱们的Mybatis配置文件的状态！发现均可以被Spring整合！
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.th.pojo"/>
</typeAliases>
</configuration>
12.5整合实现二
mybatis-spring1.2.3版以上的才有这个 .
官方文档截图 :
dao继承Support类 , 直接利用 getSqlSession() 得到 , 而后直接注入SqlSessionFactory . 比起方式1 , 不须要管理SqlSessionTemplate , 并且对事务的支持更加友好 . 可跟踪源码查看
测试：
一、将咱们上面写的UserDaoImpl修改一下
public class UserDaoImpl extends SqlSessionDaoSupport implements UserMapper {
public List<User> selectUser() {
UserMapper mapper = getSqlSession().getMapper(UserMapper.class);
return mapper.selectUser();
}
}
二、修改bean的配置
<bean id="userDao" class="com.th.dao.UserDaoImpl"> <property name="sqlSessionFactory" ref="sqlSessionFactory" /> </bean>
三、测试
@Test
public void test2(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper mapper = (UserMapper) context.getBean("userDao");
List<User> user = mapper.selectUser();
System.out.println(user);
}
总结 : 整合到spring之后能够彻底不要mybatis的配置文件，除了这些方式能够实现整合以外，咱们还可使用注解来实现，这个等咱们后面学习SpringBoot的时候还会测试整合！
13. Spring中的事务管理(完整代码)
- 要么都成功，要么都失败
- 十分重要，涉及到数据一致性
- 确保完整性和一致性
事务的ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个业务可能操做一个资源，防止数据损坏
- 持久性
- 事务一旦提交，不管系统发生什么问题，结果都不会被影响。
Spring中的事务管理
- 声明式事务
- 编程式事务
声明式事务
spring-dao.xml （名字自定义） spring的配置
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/tx
https://www.springframework.org/schema/tx/spring-tx.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-tx.aop">
<!--data source-->
<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
</bean>
<!--sqlsession-->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="datasource" />
<!--bound mybatis-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<property name="mapperLocations" value="classpath:com/mapper/*.xml"/>
</bean>
<!--声明式事务-->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<constructor-arg ref="datasource" />
</bean>
<!--结合aop实现事务置入-->
<!--配置事务的类-->
<tx:advice id="tx1" transaction-manager="transactionManager">
<!--给哪些方法配置事务-->
<!--配置事务的传播特性-->
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="*" propagation="REQUIRED"/>
<tx:method name="query" read-only="true"/>
</tx:attributes>
</tx:advice>
<!--配置事务切入-->
<aop:config>
<aop:pointcut id="txpointxut" expression="execution(* com.mapper.*.*(..))"/>
<aop:advisor advice-ref="tx1" pointcut-ref="txpointxut"/>
</aop:config>
</beans>
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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<import resource="spring-dao.xml"/>
<bean id="userMapper2" class="com.mapper.UserMapperIml2">
<property name="sqlSessionFactory" ref="sqlSessionFactory"></property>
</bean>
</beans>
UserMapper接口
package com.mapper;
import com.pojo.User;
import java.util.List;
public interface UserMapper {
List<User> selectUser();
int addUser(User user);
int delete(int id);
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mapper.UserMapper">
<select id="selectUser" resultType="user">
select * from mybatis.user;
</select>
<insert id="addUser" parameterType="user">
insert into mybatis.user (id, name, pwd) values
(#{id}, #{name}, #{pwd})
</insert>
<delete id="delete" parameterType="int">
delete from mybatis.user where id=#{id}
</delete>
</mapper>
UserMapperIml2实现类
package com.mapper;
import com.pojo.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperIml2 extends SqlSessionDaoSupport implements UserMapper {
public List<User> selectUser() {
User user = new User(6, "天魔", "333");
SqlSession sqlSession = getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
mapper.addUser(user);
mapper.delete(6);
return mapper.selectUser();
}
public int addUser(User user) {
return getSqlSession().getMapper(UserMapper.class).addUser(user);
}
public int delete(int id) {
return getSqlSession().getMapper(UserMapper.class).delete(id);
}
}
进行测试
能够先不配事务测一下，让其中一个方法错看看结果
@Test
public void test(){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper mapper = context.getBean("userMapper"，UserMapper.class);
List<User> userList = mapper.selectUser();
for(User user:userList){
System.out.println(user);
}
}
思考问题？
为何须要配置事务？
- 若是不配置，就须要咱们手动提交控制事务；
- 事务在项目开发过程很是重要，涉及到数据的一致性的问题，不容马虎！
相关文章
- 1. Spring学习《狂神说Java》 笔记
- 2. SpringCloud狂神说学习笔记（一）
- 3. SpringCloud 狂神说 学习笔记
- 4. spring 狂神说的详细笔记
- 5. 狂神说Spring笔记+源码
- 6. 狂神说 Docker笔记
- 7. 狂神jvm复习笔记
- 8. SpringCloud狂神学习笔记（二）
- 9. Redis-狂神（11. Redis.conf）学习笔记
- 10. 【狂神说】MySQL学习笔记06----事务和索引
- 更多相关文章...
- • 您已经学习了 XML Schema，下一步学习什么呢？ - XML Schema 教程
- • 我们已经学习了 SQL，下一步学习什么呢？ - SQL 教程
- • Tomcat学习笔记（史上最全tomcat学习笔记）
- • 适用于PHP初学者的学习线路和建议
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Appium入门
- 2. Spring WebFlux 源码分析(2)-Netty 服务器启动服务流程 --TBD
- 3. wxpython入门第六步（高级组件）
- 4. CentOS7.5安装SVN和可视化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig对象缺少setMaxIdle、setMaxWaitMillis等方法，问题记录
- 6. 一步一图一代码，一定要让你真正彻底明白红黑树
- 7. 2018-04-12—（重点）源码角度分析Handler运行原理
- 8. Spring AOP源码详细解析
- 9. Spring Cloud（1）
- 10. python简单爬去油价信息发送到公众号
欢迎关注本站公众号,获取更多信息
