【java框架】Spring是什么？Spring框架体系结构? Spring框架如何搭建?

Spring是什么？

Spring是一个轻量级、非侵入式、IOC和AOP 的java开发框架，是为了简化企业级的应用开发。

Spring框架是一站式框架。

解释：

• 轻量级

  spring框架使用的jar包小

  spring框架运行占用资源少、运行效率高

• 非侵入式

  spring不会侵入到业务类代码中

  因为不需要继承spring特定的类，通过依赖注入后就可以使用

• IOC 控制反转

  Inversion Of control

  就是由 Spring IOC 容器来管理对象

  不用我们再创建销毁…对象（一个对象的生命周期都不用我们去做）

• AOP 面向切面编程

  Aspect Oriented Programming

  是一种编程思想，是OOP的延续，为了帮助开发人员专注业务代码

• 一站式框架

  Spring也提供数据访问功能和web功能，以及可以很好管理其他框架

Spring的体系结构

• 数据访问/整体 (Data Access/Integration )

  JDBC java数据库连接 Java DataBase Connectivity

  ORM 对象关系映射 Object Relational Mapping

  Transactions Spring事务处理

• Web (MVC Web开发)

  WebSocket 网络套接字

  Servlet 后端服务器中处理接收和响应的代码程序

• AOP 面向切面编程 (Aspect Oriented Programming)

• Aspects AOP框架

• Messaging 消息

• 核心容器 ( Core Container)

  Beans : 管理Beans

  Core : Spring核心

  Context ： 配置文件

  SpEL ： Spring Expression Language 表达式语言

​

Spring 框架搭建

1. Maven中导入Spring核心基础jar包 spring-context ( pom.xml中)

2. 编写spring配置文件 (resources中 spring.xml文件中)

3. 编写实体类

4. 测试 不需要创建对象，spring容器中获得对象

<?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.ffyc</groupId>
    <artifactId>SpringPro</artifactId>
    <version>1.0</version>
    <name>SpringPro</name>
    <packaging>war</packaging>

    <properties>
        <maven.compiler.target>1.8</maven.compiler.target>
        <maven.compiler.source>1.8</maven.compiler.source>
        <junit.version>5.6.2</junit.version>
    </properties>

    <dependencies>
       <!--导入spring-context jar包-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.2.RELEASE</version>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>3.3.0</version>
            </plugin>
        </plugins>
    </build>
</project>

<?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"
           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/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置spring要管理的对象 -->
    <!--
        配置spring要管理的对象，spring框架管理生成的对象我们称为一个bean
        id    生成的对象名
        class 管理的类名
        name  对象别名，可以为多个
        scope 范围；
            singleton(默认值)：在Spring中只会存在一个bean实例，单例模式。
            prototype: 原型  getBean()的时候都会new Bean()
            request：每次 http 请求都会创建一个 bean，仅有于  WebApplicationContext 环境
            session: 同一个 http session 共享一个Bean, 不同 Session 使用不同的 Bean,使用环境上
    -->

    <bean id="user" class="com.ffyc.spring.model.User" scope="prototype">
        <!--1、通过set进行赋值-->
        <property name="no" value="100"></property>
        <property name="name"  value="jim"></property>
        <!--2、通过构造方法进行赋值-->
        <constructor-arg name="no" value="101"></constructor-arg>
        <constructor-arg name="name" value="jim"></constructor-arg>
    </bean>


    <!-- 注解方式，就可以不要在这生成 bean标签配置 ： 1、导入注解jar包  2、开启注解扫描-->
    <!-- 开启spring的注解扫描功能，启动时，就会扫描所配置的包下面的类-->
    <context:component-scan base-package="com.ffyc.spring"></context:component-scan>


</beans>

package com.ffyc.spring.model;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class User {

    private int no;
    private String name;

    /*
        框架：
     */
    public User(){
        System.out.println("无参的构造方法");
    }

    public User(int no, String name) {
        this.no = no;
        this.name = name;
        System.out.println("有参的构造方法");
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

package com.ffyc.spring.test;

import com.ffyc.spring.model.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args) {
        /*
             启动spring框架，读取配置文件
             IOC 控制反转 是spring的核心功能
                 控制反转是讲生成对象的权利反转给spring框架，由spring框架统一管理
         */
        ApplicationContext app = new ClassPathXmlApplicationContext("spring.xml");
        User user = app.getBean("user",User.class);
        System.out.println(user);
        User user1 = app.getBean("user",User.class);
        System.out.println(user1);
    }
}

​