zoukankan      html  css  js  c++  java
  • 关于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、测试

     

  • 相关阅读:
    【WEBI专题】解决在交叉表中计算占比、偏差、率的问题
    前导零的问题(增加/删除)
    在SAP BW中使用ABAP
    如何组织维度
    BEx Query Designer中的变量及其增强
    《魔幻手机》经典台词摘录
    今天发现了VISTA系统的一个BUG
    Online Tools And Sofrware Directory Entry
    [转载]博客园通过Word 2007发布随笔
    为你的程序增加记忆功能
  • 原文地址:https://www.cnblogs.com/zz-newbie/p/14835735.html
Copyright © 2011-2022 走看看