当前位置:   article > 正文

Spring Framework简介_org.springframework.http

org.springframework.http

1.Spring核心思想
(1)基本概念
IoC(Intversion of Control):控制反转,控制权从应用程序转移到框架,这是框架的共有特性。
IoC容器:实现了IoC思想的容器就是IoC容器,比如:SpringFramework,Guice
DI:依赖注入(Depedency Injection):用一个单独的对象(装配器)来配对对象之间的依赖关系。
(2)了解IoC容器特点
不需要主动new对象,而是描述对象应该如何被创建即可,IoC容器帮你创建,即被动实例化;
不需要主动装配装配对象之间的依赖关系,而是描述需要哪个服务(组件),IoC容器会帮你装配(即负责将它们关联在一起),被动接受装配;
主动边被动,好莱坞法则:别打电话给我们,我们打电话给你;
迪米特法则(最少知识原则):不知道依赖的具体实现,只知道需要的提供某类服务的对象(面向对象的原则),松散耦合,一个对象应当对其他对象有尽可能少的了解,不和陌生人(实现)说话;
IoC是一种让服务消费者不依赖于服务提供者的组件设计方式,是一种减少类与类之间依赖的设计原则。
(3)理解Ioc容器问题关键
谁控制谁?为什么叫反转?
答:IoC容器控制,而以前是应用程序控制,所以叫做反转。
控制什么?
答:控制应用程序所需要的资源(对象、文件……)。
控制的哪些方面被反转了?
答:程序的控制权发生了反转,从应用程序转移到了IoC容器。
(4)理解实现IoC思想的容器
容器:提供组件运行环境,管理组件生命周期(不管组件如何创建的以及它们之间的关系)
IoC容器不仅仅具有容器的功能,而且还具有一些其他的特性,比如依赖装配。
由于控制反转概念太广泛,所以后来Martin Fowler提出依赖注入——DI容器概念。
在后来我们将IoC和控制反转都叫DI
(5)理解DI问题关键
*谁依赖谁?
应用程序依赖IoC容器
*为什么依赖?
应用程序依赖IoC容器装配类之间的关系
*依赖什么东西?
依赖IoC容器的装配功能
*谁注入谁?
IoC容器注入应用程序
*注入什么东西?
注入应用程序需要的资源(类之间的关系)
DI容器:主要我们的IoC容器具备了依赖功能我们就叫做DI容器。我们的Spring框架是一个DI容器。
(6)理解DI优点
*帮你看清组件之间的依赖关系,只需要观察依赖注入的机制(setter/构造器),就可以掌握整个依赖(类与类之间的关系)
*组件之间的依赖关系由容器在运行期决定,形象的来说,即由容器动态的将某种依赖关系注入到组件中。
*依赖关系注入的目标并非为软件系统带来更多的功能,而是为了提升组件重用的概率,并未系统搭建一个灵活、可扩展的平台。通过依赖注入机制,我们只需要通过简单的配置,而无需任何代码就可指定目标需要的资源,完成自身的业务逻辑,而不用关心具体的资源来源。
注意:使用DI限制,组件(我们自己写的)和装配器(IoC容器)之间不会有依赖关系(有没有关系就看有没有导入它的包),因此组件无法从适配器那里获得更多服务,只能获得配置信息中所提供的那些。
2.Spring框架的设计哲学
Spring框架的原则:
在每个层次偶提供选择: Spring允许你尽可能推迟设计决策。你可以不更改代码的情况下通过配置切换持久化性提供者。
容纳不同的观点: 拥抱变化。
保持强烈的向后兼容性: Spring支持精心选择的JDK版本和第三方库,以促进依赖于Spring的应用程序和库的维护。
关心API设计: Spring团队将大量思想和时间投入到制作api。
二、Spring生态
关系数据库:
非关系数据库:
三、Spring应用案例(spring官网:https://spring.io/)
实现计算图形面积和周长:
(1)pom.xml:

<?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">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.wschase.springcore</groupId>
    <artifactId>springcore-maven-case</artifactId>
    <version>1.0.0</version>
<!--Spring框架的物料清单-->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-framework-bom</artifactId>
                <version>4.3.9.RELEASE</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!--Spring框架依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

</project>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

(2)application-context.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: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">


    <!--容器里面关于对象信息的描述-->
    <bean id="circular" class="com.wschase.spring.common.impl.Circular">
        <constructor-arg  name="radius" value="10"/>
    </bean>

    <bean id="triangle" class="com.wschase.spring.common.impl.Triangle">
        <constructor-arg  name="a" value="10"/>
        <constructor-arg  name="b" value="24"/>
        <constructor-arg  name="c" value="20"/>
    </bean>

    <bean id="rectangle" class="com.wschase.spring.common.impl.Rectangle">
        <constructor-arg  name="height" value="10"/>
        <constructor-arg  name="width" value="20"/>
    </bean>

    <!--容器会根据这些信息来创建我们的对象-->
    <bean id="xmlShapeCompute" class="com.wschase.spring.xml.XmlShapeCompute">
        <property name="circular" ref="circular"/>
        <property name="rectangle" ref="rectangle"/>
        <property name="triangle" ref="triangle"/>
    </bean>
</beans>
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33

(3)计算图形面积、周长的接口

package com.wschase.spring.common;

/**
 * Author:WSChase
 * Created:2019/4/17
 */
public interface Shape {

    /**
     * 计算图形面积
     * @return
     */
    double computeArea();


    /**
     * 计算图形周长
     * @return
     */
    double computeSide();
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

(4)圆、长方形、三角形各自的类

package com.wschase.spring.common.impl;


import com.wschase.spring.common.Shape;

/**
 * Author:WSChase
 * Created:2019/4/17
 */
public class Circular implements Shape {
    private final double radius;

    public Circular(double radius) {
        this.radius = radius;
    }

    public double computeArea() {
        return Math.PI*Math.pow(this.getRadius(),2);
    }

    public double computeSide() {
        return 2*Math.PI*this.getRadius();
    }


    //fianl类型只有set方法
    public double getRadius() {
        return radius;
    }

    @Override
    public String toString() {
        return "Circular{" +
                "radius=" + radius +
                ",area="+this.computeArea()+
                ",side="+this.computeSide()+
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
package com.wschase.spring.common.impl;

import com.wschase.spring.common.Shape;

/**
 * Author:WSChase
 * Created:2019/4/17
 */
public class Rectangle implements Shape {
    //宽
    private final double width;

    private final double height;

    public double getWidth() {
        return width;
    }

    public double getHeight() {
        return height;
    }


    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    //高
    public double computeArea() {
        return this.getWidth()*this.getHeight();
    }

    public double computeSide() {
        return 2*(this.getHeight()+this.getWidth());
    }

    @Override
    public String toString() {
        return "Rectangle{" +
                "width=" + width +
                ", height=" + height +
                ",area="+this.computeArea()+
                ",side="+this.computeSide()+
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
package com.wschase.spring.common.impl;

import com.wschase.spring.common.Shape;

/**三角形
 * Author:WSChase
 * Created:2019/4/17
 */
public class Triangle implements Shape {
    private final double a;
    private final double b;
    private final double c;

    public Triangle(double a, double b, double c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public double getA() {
        return a;
    }

    public double getB() {
        return b;
    }

    public double getC() {
        return c;
    }

    public double computeArea() {
        double q=(this.computeSide())/2;
        double s=Math.sqrt(
                (q-a)*(q-b)*(q-c)*q
        );
        return 0;
    }

    public double computeSide() {
        return this.getA()+this.getB()+this.getC();
    }

    @Override
    public String toString() {
        return "Triangle{" +
                "a=" + a +
                ", b=" + b +
                ", c=" + c +
                ",area="+this.computeArea()+
                ",side="+this.computeSide()+
                '}';
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55

(5)

package com.wschase.spring.xml;

import com.wschase.spring.common.Shape;

/**
 * Author:WSChase
 * Created:2019/4/17
 */
public class XmlShapeCompute {

    public Shape  circular;

    public Shape triangle;

    public Shape rectangle;

    public Shape getCircular() {
        return circular;
    }

    public void setCircular(Shape circular) {
        this.circular = circular;
    }

    public Shape getTriangle() {
        return triangle;
    }

    public void setTriangle(Shape triangle) {
        this.triangle = triangle;
    }

    public Shape getRectangle() {
        return rectangle;
    }

    public void setRectangle(Shape rectangle) {
        this.rectangle = rectangle;
    }

    public Shape computeShape(String shapeName){
        if(shapeName==null||shapeName.length()==0){
            throw new IllegalArgumentException("Not found shape");
        }
        if(shapeName.equals("circular")){
            return circular;
        }
        if(shapeName.equals("triangle")){
            return triangle;
        }

        if(shapeName.equals("rectangle")){
            return rectangle;
        }
        throw new IllegalArgumentException("Not found shape"+shapeName);
    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59

(6)主类:

package com.wschase.spring.xml;

import com.wschase.spring.common.Shape;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**这是一个主类
 * Author:WSChase
 * Created:2019/4/17
 */
public class XmlApplication {
    public static void main(String[] args) {

        //我们通过new的方式创建了一个容器
        ApplicationContext context=
                new ClassPathXmlApplicationContext("application-context.xml");

        //在容器里面取找这个name(id)对应的对象,找到之后会将对象返回给我们:
        //           这个时候我们获取对象就没有通过new来创建对象
    XmlShapeCompute xmlShapeCompute= (XmlShapeCompute) context.getBean("xmlShapeCompute");

    Shape shape=xmlShapeCompute.computeShape(args[0]);
        System.out.println(shape);
    }

}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

从上面的例子我们可以看出来我们并没有通过new来实例化对象,而是通过容器寻找到对象相关的信息,它返回给我们需要的对象。

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/AllinToyou/article/detail/84812
推荐阅读
相关标签
  

闽ICP备14008679号