关于Spring框架

一、 Spring框架概述

1、 Spring是一个轻量级的开源的JavaEE框架

2、 Spring可以解决企业应用开发的复杂性

3、 Spring有两个核心部分:IoC和AoP

IoC:反转控制,把创建对象过程交给Spring进行管理

AoP:面向切面,不修改源代码进行功能增强

4、Spring特点

(1)方便解耦,简化开发

(2)AoP编程支持

(3)方便程序的测试

(4)方便集成各种优秀的框架

(5)方便进行事务的操作

(6)降低API的使用难度

二、入门案例

1、下载Spring5

2、打开eclipse工具,创建普通Java工程

3、导入Spring5相关jar包

4、创建普通类,在这个类创建普通方法

public class User {
  publi void add(){
•    System.out.println("add.........");
  }
}

5、创建配置文件,在配置文件配置创建的对象

(1)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="userImpl" class="com.test1.ioc.UserImpl">bean>
beans>

6、进行测试代码编写

二、IoC(概念和原理)

1、什么是IoC

(1)控制反转,把对象的创建和对象之间的调用过程,交给Spring进行管理

(2)使用IOC目的:为了降低耦合度

(3)入门案例就是IOC实现

2、IOC底层原理

(1)xml解析、工厂模式、反射

IOC过程:

第一步:xml配置文件,配置创建的对象

<bean id="dao" class="com.atguigu.UserDao">
bean>

第二步 有service类和dao类,创建工厂类

Class UserFactory{
public static UserDao getDao(){
       
      //xml解析,class属性值为com.atguigu.UserDao
      String classValue = class属性值;
       
      //通过反射创建对象
      Class clazz = Class.forName(classValue);
       
      // newInstance();方法创建对象
      return (UserDao)clazz.newInstance();
}
}

三、IOC(接口)

1、IOC思想基于IOC容器完成,IOC容器底层就是对象工厂

2、Spring提供IOC 容器实现两种方式:(两个接口)

• BeanFactory: IOC容器基本实现,是Spring内部的使用接口,不提供开发人员使用

特点:加载配置文件的时候不会创建对象,在获取(使用)对象才会创建对象

• ApplicationContext:BeanFactory接口的子接口,提供更多强大的功能,一般由开发人员进行使用

特点:加载配置文件的时候就会把在配置文件中的对象创建

ApplicationContext接口有两个主要的实现类

• FileSystemXmlApplicationContext

特点:电脑系统的位置,比如在电脑的C盘中的某个位置

• ClassPathXmlApplicationContext

特点:比如在src下面

四、IOC操作Bean管理

1、什么是Bean管理,Bean管理指的是两个操作

• Spring创建对象

• Spring注入属性

2、Bean管理操作有两种方式

(1)基于xml配置文件方式

(2)基于注解方式实现

(3)创建对象时候,默认也是执行无参数构造方法

IOC操作Bean管理(基于xml方式)

1、基于xml方式创建对象

 

• 在spring配置文件中,使用bean标签,标签里面添加对应属性,就可以实现对象创造

• 在bean标签里面有很多属性,介绍常用的属性

id属性:唯一标识

class属性:类全路径(包和类的路径,见上图)

name属性:和id属性作用一样,但是id中不可以加特殊 符号,而name中可以加特殊符号

2、基于xml方式注入属性

(1)DI:依赖注入,就是注入属性,有如下几种方法:

第一种注入方式:使用set方法进行注入

1)创建类,定义属性和对应的set方法

/**
* 演示使用set方法进行注入属性
*/
public class Book {

 //创建属性
 private String bNameString;

 //创建属性对应的set方法
   
 public void setbNameString(String bNameString) {
  this.bNameString = bNameString;
}
}
2)  在Spring配置文件中配置对象创建,配置属性注入

 

进行测试:
@Test
public void testBook(){
//1、加载spring配置文件,有两个接口都可实现
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
//2、获取配置创建的对象
Book book = context.getBean("book", Book.class);
System.out.println(book);
book.testPrint();
}

第二种注入方式:使用有参数构造方法进行注入

1)创建一个类,创建类的带参数构造函数

2)在xml里面进行配置:


<bean id="books" class="com.test1.ioc.Book1">

  <constructor-arg name="a" value="abc">constructor-arg>
  <constructor-arg name="b" value="123">constructor-arg>
 
 

bean>

第三种注入方式:P名称空间注入(了解)

1)使用p名称空间注入,可以简化基于xml配置方式

2)进行属性注入,在bean标签里面进行操作

3、IOC操作Bean管理(xml注入其他类型属性)

1)字面量

(1)null值

(2)属性值包含特殊符号

2)注入属性-外部bean

(1)创建两个类service类和dao类

(2)在service调用dao里面的方法

(3)在spring配置文件中进行配置

-------------------------------------------------------------------图片分割线---------------------------------------------------------------------------

3)、注入属性-内部bean和级联赋值

(1)一对多关系:部门和员工,一个部门有多个员工,一个员工属于一个部门

(2)在实体类之间表示一对多关系,员工表示所属部门,使用对象类型属性进行表示

//部门类
public class Department {
private String dName;
public void setdName(String dName) {
this.dName = dName;
}
public String toString() {
return dName;
}
}

//员工类
public class Employee {
private String eName;
private String gender;
//员工属于某一个部门,使用对象形式表示
private Department dept;
public void setDept(Department dept) {
this.dept = dept;
}
public void seteName(String eName) {
this.eName = eName;
}
public void setGender(String gender) {
this.gender = gender;
}
}

(3)在spring配置文件中进行配置

4、注入属性-级联赋值

(1)第一种写法:

在3的基础上只改动spring配置文件

(2)第二种写法:

基于第一种写法中的Employee类和Department类,在Employee类中增加了dept对象的get方法

 

5、IOC操作Bean管理(xml注入集合属性)

1、 注入数组类型属性

2、 注入List集合类型属性

3、 注入Map集合类型属性

(1)创建类,定义数组、List、Map、Set类型属性,并且生成对应的set方法,Beans1.xml

public class Gather {

//1、数组类型属性
private String[] course;

//2、List集合类型属性
private List<String> list;

//3、Map集合类型属性
private Map<String, String> maps;

//4、Set集合类型属性
private Set<String> set;

public void setSet(Set<String> set) {
this.set = set;
}

public void setList(List<String> list) {
this.list = list;
}

public void setMaps(Map<String, String> maps) {
this.maps = maps;
}

public void setCourse(String[] course) {
this.course = course;
}
}

(2)在spring配置文件进行配置


<bean id="gather1" class="com.collection.type.Gather">

<property name="course">
<array>
<value>Java课程value>
<value>MySQL课程value>
<value>计算机组成原理value>
array>
property>


<property name="list">
<list>
<value>PHPvalue>
<value>JavaScriptvalue>
<value>HTMLvalue>
list>
property>


<property name="maps">
<map>
<entry key="张三" value="小三">entry>
<entry key="李四" value="小四">entry>
<entry key="王五" value="小五">entry>
map>
property>


<property name="set">
<set>
<value>SQLvalue>
<value>Redisvalue>
<value>Spring5value>
set>
property>
bean>
beans>

4、 在集合里面设置对象类型值

(1) 先创建一个course类,类里面创建成员变量并创建set方法

(2) 在上面1、2、3中Gather类的基础上如下创建

(3)对Spring配置文件进行配置


<property name="courseList">
<list>
<ref bean="course1">ref>
<ref bean="course2">ref>
list>
property>
bean>


<bean id="course1" class="com.collection.type.Course">
<property name="name" value="Spring5框架课程">property>
bean>

<bean id="course2" class="com.collection.type.Course">
<property name="name" value="Mybatis框架课程">property>
bean>

5、把集合注入部分提取出来,作为公共部分(重新创建配置文件Beans2.xml)

(1) 在spring配置文件中引入名称空间,如下图

(2)使用uitl标签完成list集合

6、IOC操作Bean管理(FactoryBean)

1)、 Spring有两种类型bean,一种普通bean,一种工厂bean(FatoryBean)

2)、 普通bean:在配置文件中定义bean类型就是返回类型

3)、 工厂bean:在配置文件定义bean类型可以和返回类型不一样

第一步:创建类,让这个类作为工厂bean,实现接口FatoryBean

第二步:实现接口里面的方法,在实现的方法中定义返回的bean

public class MyBean implements FactoryBean<Course>{

//定义返回bean
@Override
public Course getObject() throws Exception {
Course course = new Course();
course.setName("王季青");
return course;
}

@Override
public Class getObjectType() {
// TODO Auto-generated method stub
return null;
}
}

7、IOC操作Bean管理(Bean的作用域)

1、 在Spring里面,设置创建bean实例是单实例还是多实例

2、 在Spring类里面,默认情况下,bean是单实例对象

3、 如何设置单实例还是多实例

(1) 在spring配置文件bean标签里面有属性用于设置单实例还是多实例

(2) scope属性值:

第一个值:默认值,singleton,表示单实例对象

第二个值:prototype,表示多实例对象

(3) singleton和prototype区别

第一:前者表示单实例,后者表示多实例

第二:设置scope值为singleton时候,加载spring配置文件时候就会创建单实例对象;而设置scope值为prototype时候,不是在加载spring配置文件时候创建对象,在调用getBean方法时候创建多实例对象;

scope还有两个值,如下:

request:一次请求

session:一次会话

7、IOC操作Bean管理(Bean的生命周期)

1、 生命周期

(1) 从对象创建到对象销毁的全过程

2、 bean生命周期

(1) 通过构造器创建bean实例(无参构造)

(2) 为bean的属性设置值和对其他bean的引用(调用set方法)

(3) 调用bean的初始化的方法(需要进行配置初始化方法)

(4) bean可以使用了(getBean方法获取对象)

(5) 当容器关闭时,调用bean的销毁方法(需要进行配置销毁的方法)

3、 演示bean的生命周期

演示的类:
public class LifeCycleTest {
//无参数构造
public LifeCycleTest() {
System.out.println("第一步 执行无参数构造创建bean实例");
}

private String name;
public void setName(String name) {
this.name = name;
System.out.println("第二步 调用set方法设置属性的值");
}
//创建执行初始化的方法
public void initMethod() {
System.out.println("第三步 执行初始化的方法");
}
//创建执行销毁的方法
public void destroyMethod() {
System.out.println("第五步 执行销毁的方法");
}
}

Spring配置文件:

测试方法:

4、 bean的后置处理器,bean的生命周期有七个步骤

在上面的五个步骤中,还有两个步骤:

(1) 通过构造器创建bean实例(无参构造)

(2) 为bean的属性设置值和对其他bean的引用(调用set方法)

(2~3)把bean实例传递bean后置处理器的方法

(3) 调用bean的初始化的方法(需要进行配置初始化方法)

(3~4)把bean实例传递bean后置处理器的方法

(4) bean可以使用了(getBean方法获取对象)

(5) 当容器关闭时,调用bean的销毁方法(需要进行配置销毁的方法)

5、 演示添加后置处理器效果

(1) 创建类,实现接口BeanPostProcessor,创建后置处理器

8、IOC操作Bean管理(xml自动装配)

1、 什么是自动装配?

(1) 根据指定装配规则(属性名称或者属性类型),Spring自动将匹配的属性值进行注入

2、 演示自动装配过程

(1) 根据属性名称自动注入

(2) 根据属性类型自动注入 在上面(1)的配置文件中将byName改为byType即可,而且无需id值和类型的声明一样(一样或不一样结果不变) 不过注意:当相同的类型有多个时,要用byName而不用byType,如下情况不可用byType:

9、IOC操作Bean管理(引入外部属性文件)

1、 直接配置数据库信息

(1) 配置连接池(此处用德鲁伊连接池)

(2) 引入德鲁伊连接池依赖jar包

 

2、 引入外部属性文件配置数据库连接池

(1) 创建外部属性文件,properties格式文件,数据库信息

(2) 把外部properties属性文件引入到spring配置文件中

引入context名称空间

在spring配置文件使用标签引入外部属性文件

10、IOC操作Bean管理(基于注解方式)

1、 什么是注解

(1) 注解是代码特殊标记,格式:@注解名称(属性名称=属性值,属性名称=属性值...)

(2) 使用注解,注解可以作用在类上面,方法上面,属性上面

(3) 使用注解目的:简化xml配置

2、 Spring针对Bean管理中创建对象提供注解

(1)@Component

(2)@Service

(3)@Controller

(4)@Repository

上面的四个注解功能是一样的,都可以用来创建bean实例

3、基于注解方式实现对象创建

(1) 引入依赖

*

(2)开启组件扫描

*

4、开启组件扫描细节配置

5、基于注解方式实现属性注入

(1)@AutoWired:根据属性类型进行自动装配

第一步:把service和dao对象创建,在service和dao类添加创建对象注解

第二步: 在service注入dao对象,在service类添加dao类型属性(不需要添加set方法),在属性上面使用注解

 

(2)@Qualifier :根据属性名称进行注入

这个@Qualifier注解的使用,和上面@AutoWired一起使用

*

*

(3)@Resource :可以根据类型注入,也可以根据名称注入

在上面(1)和(2)中类的基础上如下变更即可

**

(4)@Value :注入普通类型属性

 

6、 完全注解开发

(1) 创建配置类,替代xml配置文件

 

(2) 编写测试类

 

五、AOP(概念)

1、什么是AOP?

(1)面向切面编程(方面),利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率。

(2)通俗描述:通过不修改源代码的方式,在主干功能里面添加新功能。

2、AOP底层原理

(1) AOP底层使用动态代理

  1) 有两种情况动态代理

     第一种:有接口情况,使用JDK动态代理,创建接口实现类代理对象,增强类的方法

 

    第二种:没有接口情况,使用CGLIB动态代理

3、 AOP(JDK动态代理)

(1) 使用JDK动态代理,使用Proxy类里面newProxyInstance方法创建代理对象

 

 

方法里面有三个参数:

第一个参数:类加载器

第二个参数:增强方法所在的类,这个类实现的接口,支持多个接口

第三个参数:实现这个接口InvocationHandler,创建代理对象,写增强的方法

(2) 编写JDK动态代理代码

1) 创建接口,定义方法

 

 

2) 创建接口实现类,实现方法

 

3) 使用Proxy类创建接口代理对象

方法一:创建JDKProxyFirst类,并且在JDKProxyFirst类里面再编写class UserProxy内部类,创建UserProxy类并且要让这个类实现InvocationHandler接口以及接口里面的invoke方法,如下图

 

 

方法二:匿名内部类的实现方式,创建JDKProxySecond类,然后在测试类里面调用JDKProxySecond类里面的方法,如下图

 

测试类如下:

 

4、 AOP(术语)

(1)连接点

类里面的哪些方法可以被增强,这些方法就称为连接点 (2)切入点 实际被真正增强的方法,称为切入点 (3)通知(增强) 1)实际增强的逻辑部分称为通知(增强) 2)通知有多种类型,如下 *前置通知 *后置通知 *环绕通知 *异常通知 *最终通知

(4)切面(是一个动作) 把通知应用到切入点过程(如:在登录功能中加一个权限判定的新功能,这就是一个切面)

5、 AOP操作(准备)

1、 Spring框架一般基于AspectJ实现AOP操作

(1) 什么是AspectJ

* AspectJ不是Spring组成部分,是一个独立AOP框架,一般把AspectJ框架和Spring框架一起使用,进行AOP操作

2、基于AspectJ实现AOP操作

(1) 基于xml配置文件

(2) 基于注解方式实现(一般使用注解方式)

3、在项目工程里面引入AOP相关依赖

 

4、切入点表达式

(1) 切入点表达式作用:知道哪个类里面的哪个方法进行增强

(2) 语法结构:

Execution(权限修饰符类全路径([参数列表]))

举例1:对com.type.test.Test类里面的test方法进行增强

execution(*com.type.test.Test.test(..))

举例2:对com.type.test.Test类里面的所有方法进行增强

execution(com.type.test.Test.(..))

举例3:对com.type.test包里面的所有类,类里面的所有方法进行增强

execution(* com.type.test..(..))

6、 AOP操作(AspectJ注解)

1、 创建类,在类里面定义方法

 

2、 创建增强类(编写增强逻辑),在类里面创建方法,让不同的方法代表不同通知类型

 

3、进行通知的配置

(1) 在spring配置文件中,开启注解扫描

 


<context:component-scan base-package="AnnotationAOP">context:component-scan>

(2)使用注解创建User和UserProxy对象

 

 

(3)在增强类上面添加注解@Aspect

 

(4)在spring配置文件中开启生成代理对象

 


<aop:aspectj-autoproxy>aop:aspectj-autoproxy>

4、配置不同类型的通知

(1)在增强类的里面,在作为通知方法上面添加通知类型注解,使用切入点表达式配置

 

测试类

 

5、公共切入点抽取

 

6、有多个增强类对同一个方法进行增强,设置增强类优先级

(1)在增强类上面添加注解@Order(数字类型值)

7、AOP操作(AspectJ配置文件)

1、创建两个类,增强类和被增强类,创建方法

 

 

2、在spring配置文件中创建两个类对象

3、 在spring配置文件中配置切入点

 

8、AOP操作(完全注解)

1、创建配置类

 

2、测试

 

原文地址:https://www.cnblogs.com/zz-newbie/p/14835735.html