Spring学习笔记-Spring之旅-01

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

使用Spring简化JAVA开发

Spring的四种关键策略：

●基于POJO的轻量级和最小侵入式编程；

●通过依赖注入（DI）和面向接口实现松耦合；

●基于切面（AOP）和惯例进行声明式编程。

●通过切面和模板减少样板式代码。

几乎Spring所做的任何事都可以追溯到上面的一条或多条策略。

依赖注入（DI）

传统编程经常需要多个对象相互协作完成某个功能，每个对象管理与自己相互协作的对象。

传统开发常见的例子

比如下面的例子

一个Amercan类，其中有一个sayHello方法。

一个DoSomething类，调用American类执行sayHello方法。

public class  American{

     public void sayHello(){

         System.out.println("American say hello");

     }

 }

public class DoSomething{

    private American american;  //声明一个American类

    DoSomething(){

        this.american=new American();  //构造函数中初始化American类变量，这里与其紧耦合

    }

    public void do() {

        person.sayHello();

    }

}

public class Test {

    public static void main(String[] args){

        DoSomething doSomething=new DoSomething();

        doSomething.sayHello();

    }

}

可以发现在DoSomething类的构造函数自行创建了American类，与其紧密耦合在了一起，后期扩展、测试会面临很大困难。

改善后的例子:

public interface Person{

     public void sayHello()；

 }

public class  American implements{

     public void sayHello(){

         System.out.println("American say hello");

     }

 }

public class DoSomething{

    private Person person;  //声明一个Person接口

    DoSomething(Person person){

        this.person=person;  //person通过构造参数传入

    }

    public void do() {

        person.sayHello();

    }

}

public class Test {

    public static void main(String[] args){

        DoSomething doSomething=new DoSomething(new American);  //在构造函数中传入Perison实现

        doSomething.sayHello();

    }

}

现在使声明一个Person接口，在DoSomething声明一个Person接口，将Person接口的实例通过构造器参数传入，没有与任何实现产生耦合，只要实现了Person接口的类都能sayHello。

使用Spring装配bean和注入

Spring有多中装配bean的方式，以下为2种常用的方式：

●XMl

●注解

以下以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"

        xmlns:aop="http://www.springframework.org/schema/aop"

        xmlns:tx="http://www.springframework.org/schema/tx"

        xmlns:context="http://www.springframework.org/schema/context"

        xsi:schemaLocation="

            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"

        >

    <bean id="doSomething" class="com.xyd.demo1.DoSomething">

        <constructor-arg ref="person"/>    <!-- 注入American -->

    </bean>

    <bean id="person" class="com.xyd.demo1.American"><!-- American类  -->

    </bean>

</beans>

以上xml声明了2个bean，一个DoSomething类，同时构造参数传入了American bean的引用。一个American类。

下面修改测试代码

    public static void main(String[] args) {

        //DoSomething doSomething=new DoSomething(new American());

        //doSomething.doing();

        ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("SayHello.xml");

        DoSomething doSomething=context.getBean(DoSomething.class);

        doSomething.doing();

    }

使用XML应用上下文装载配置文件，然后使用getBean获得DoSomething类的实例，然后直接调用其doing()方法，输出American say hello!

四月 07, 2018 10:48:13 下午 org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
信息: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@506c589e: startup date [Sat Apr 07 22:48:13 CST 2018]; root of context hierarchy
四月 07, 2018 10:48:13 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [SayHello.xml]
American say hello!

XML应用上下文获得了bean配置文件，得到DoSomething的引用后只需要简单的调用doing()就可以了，这个类完全不知道传入的是哪个Person接口的实例，只有配置文件中知道哪个实例被传入。

应用切面（AOP）

DI能然相互协作的软件保持松耦合，面向切面（AOP）允许把遍布应用各处的功能分离出来形成可重用的组件。如需要在调用sayHello记录一下日志等等，通常称为横切关注点，借助AOP可以使这些服务模块化。

还是以上述例子，但是要增加一个功能，比如美国人说hello之前进行询问，之后给一个回应。

public class Reply {

    public void sayHelloBefor(){    //sayHello前调用

        System.out.println("say hello please!");

    }

    public void sayHelloAfter(){    //sayHello之后调用

        System.out.println("really good");

    }

}

传统的的做法是下面这样

public class DoSomething {

    Person person;

    Reply reply=new Reply();

    public DoSomething(Person person){

        this.person=person;

    }

    public void doing(){

        reply.sayHelloBefor();    //DoSomething应该管理它吗？

        person.sayHello();

        reply.sayHelloAfter();

    }

}

程序正常输出了

say hello please!
American say hello!
really good

但是这简单的代码变的复杂，如果还需要没有人进行回应的场景那会变得更复杂，而利用AOP可以声明在sayHello前必须进行请求和询问，而DoSomething本身不需要访问Reply的代码，下面修改配置文件。

<?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"

        xmlns:tx="http://www.springframework.org/schema/tx"

        xmlns:context="http://www.springframework.org/schema/context"

        xsi:schemaLocation="

            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd

            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd"

        >

    <bean id="doSomething" class="com.xyd.demo1.DoSomething">

        <constructor-arg ref="person"/>    <!-- 注入American -->

    </bean>

    <bean id="person" class="com.xyd.demo1.American"> <!-- American类  -->

    </bean>

    <bean id="reply" class="com.xyd.demo1.Reply">    <!-- Reply类  -->

    </bean>

    <aop:config>

        <aop:aspect ref="reply">    <!-- 引用reply bean  -->

            <aop:pointcut id="sayHello"  expression="execution(* *.doing(..))" /> <!-- 定义切点( AspectJ切点表达式 )-->

            <aop:before method="sayHelloBefor" pointcut-ref="sayHello"/>    <!-- 声明前置通知 -->

            <aop:after method="sayHelloAfter"  pointcut-ref="sayHello"/>        <!-- 声明后置通知 -->

        </aop:aspect>

    </aop:config>

</beans>

接下来运行一下程序，输出如下结果。

say hello please!
American say hello!
really good

AOP所做的事情，就是通过少量的配置，就可以吧Reply声明为一个切面，Reply仍然是一个POJO，不需要改变现有代码。

Bean容器

在Spring的应用中，应用对象生存于Spring容器中，容器负责创建、装配它们，配置并且管理对象的整个声明周期。容器是Spring框架的核心，使用DI管理构成应用的组件，会创建相互协作的组件之间的关联。

Spring中容器并不只有一个，其自带了多个容器实现，可归类为两种不同类型：

● bean工厂（由org.springframework.beans.factory.eanFactory接口定义，最简单，提供基本的DI支持）

● 应用上下文（由org.springframework.context.applicationContext接口定义，基于BeanFactory构建，提供应用框架级别的服务，例如从属性解析文本以及发布应用实践给感兴趣的事件监听者）

常用的容器类型为应用上下文，经常遇到的应用上下文：

● AnnotationConfigApplicationContext:从一个或多个基于Java的配置类中加载Spring上下文；

● AnnotationConfigApplicationContextAnnotationConfigWebApplicationContext:从一个或多个基于Java的配置类中加载Spring Web的应用上下文

● ClassPathXmlApplicationContext:从类路径下的一个或多个XML配置文件中加载上下文定义，把应用上下文的定义文件作为类资源。

● FileSystemXmlapplictioncontext:从文件系统下的一个或多个XML配置文件中加载上下文定义。

● XMLWebApplicationContext：从Web应用下的一个或多个XMl配置文件中加载上下文定义。

无论使用何种类型的应用上下文，将bean加载到bean工厂的过程都是相似的。

下面的代码加载一个xml配置文件的应用上下文：

ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("SayHello.xml");

获得应用上下文之后，就可以调用上下文的getBean()方法获得bean。

bean的生命周期

1、对bean进行实例化，new；

2、将值和bean的引用注入到bean对应的属性中；

3、如果bean实现了BeanNameAware接口，则将bean的ID传递给setBean-Name()方法；

4、如果bean实现了BeanFactoryAware接口，则调用setBeanFactory()方法，将BeanFactory容器实例传入；

5、如果bean实现了ApplicationContextAware接口，则将调用setApplicationContext()方法，将bean所在的应用上下文的引用传进来；

6、如果bean实现了BeanPostProcessor接口，则将调用它们的post-ProcessBeforeInitialization()方法；

7、如果bean实现了InitializeingBean接口，则将调用它们的after-PropertiesSet()方法，类似如果bean使用init-method声明了初始化方法，此方法也会调用。

8、如果bean实现了BeanPostProcessor，则将调用它们的post-ProcessAfterInitialization()方法；

9、此时bean已经准备就绪，可以被应用使用，它们将一直驻留在应用上下文中，直到上下文被销毁；

10、如果bean实现了DisposableBean接口，将调用它的destroy()接口方法，同样，如果bean使用destroy-method声明了销毁方法，该方法也会被调用；

正文

使用Spring简化JAVA开发

依赖注入（DI）

传统开发常见的例子

使用Spring装配bean和注入

应用切面（AOP）

Bean容器

bean的生命周期

相关阅读

关于go深度学习框架交流的信息

go语言爬虫基础学习，go语言实战

学习delphi需要什么c语言，delphi入门与提高实用教程

软件开发需要学习c语言，软件开发与编程需要什么学历

如何快速的学习基本js技术，js怎么学最快

macos学习app，mac os使用教学

小白在哪里学习c语言，小白自学c语言

学习c语言表情包，c语言表情

目录[+]

使用Spring简化JAVA开发

依赖注入（DI）

传统开发常见的例子

使用Spring装配bean和注入

应用切面（AOP）

Bean容器

bean的生命周期

相关阅读

关于go深度学习框架交流的信息

go语言爬虫基础学习，go语言实战

学习delphi需要什么c语言，delphi入门与提高实用教程

软件开发需要学习c语言，软件开发与编程需要什么学历

如何快速的学习基本js技术，js怎么学最快

macos学习app，mac os使用教学

小白在哪里学习c语言，小白自学c语言

学习c语言表情包，c语言 表情

目录[+]

学习c语言表情包，c语言表情