JavaEE初学01

Spring

对于Java编程来说，使用Spring能完成的更加快速，更容易并且更安全。Spring专注于速度，便捷与开发效率，也正是因为如此，让Spring成为了全世界最流行的Java框架。

从配置到安全，web应用到大数据，不管你的应用架构需要用到什么，Spring都有合适的开发框架来帮你搭建项目。Spring是基于模块化设计的，所以你可以从最小集开始，只使用你需要的。

一般说Spring框架，指的是Spring Framework框架，提高开发效率的框架。但是Spring除Spring Framework框架外常用的还有Spring boot框架、Spring Data框架、Spring Cloud框架等

Spring 官方文档

Spring Framework

Spring Framework 属于 Spring 种最基础，最核心的部分，Spring 下的其它框架大部分都依赖Spring Framework。

对于整个Spring Framework来说，是学习、使用Spring生态项目的基石，也就是说，我们要引入其它Spring项目作为我们的依赖框架时，也会使用到Spring Framework。

Spring Framework的子模块：

Spring Framework

Core Container

Core Container就是核心容器，这个模块由四个模块组成：Spring-Core、Spring-Beans、Spring-Context、Spring-Context-Support and Spring-Context-Expression（Spring-Context-Expression Language）

Spring-Core和Spring-Beans模块提供了整个Spring框架最基础的设施：IOC（Inversion Of Control 控制反转）和DI（Dependency Injection 依赖注入）

这部分功能相当于所有Spring框架运行的基础，之前操作对象都需要手动去new对象，由对象作用域决定对象的生命周期（比如在某个类里new对象，对象就只存在于这个类里），而使用Spring后，由框架提供的统一容器来实例化和管理对象，并自动组织对象之间的关系，这种容器称为IOC容器（也叫Spring-Beans容器或Spring容器）

容器：容器与集合相似，集合的主要功能就是可以存储和取出数据，而容器则是存储和取出对象以及创建对象和管理对象之间的依赖（A对象属性为B对象，则A和B就产生依赖）

IOC

大多数代码都是由两个或更多的类通过彼此的合作来实现逻辑，这就会造成每个对象都需要获取与其合作的对象（也就是每个对象所依赖的对象）的引用。如果这个过程需要通过自身来实现，这就会导致代码的高度耦合并且难以维护和调试。

IOC，是面向对象编程种的一种设计原则，用来降低代码之间的耦合度。系统通过引入IOC模式中的IOC容器，即可通过容器来管理对象的生命周期和依赖关系等，从而使得代码的耦合度降低（降低学习成本），由于对象的控制权从应用程序转换为容器，控制权发生了反转，所以叫控制反转。

实现了控制反转的容器，就叫做IOC容器。（如Spring Framework）

DI

DI，是实现IOC的方法之一，所谓依赖注入，就是在IOC容器运行的过程中，动态的将某种依赖关系注入到对象里（把一个对象注入到另一个对象的属性里面）。所以DI和IOC是从不同角度描述的同一件事情。DI就是指通过引入IOC容器，使用依赖注入的方式降低代码的耦合度。

---

IOC及DI作用为：解耦

Spring 容器的使用

Spring容器的API有BeanFactory和ApplicationContext 两大类，他们都是顶级接口。其中ApplicationContext是BeanFactory的子接口。

注入的流程

启动Spring容器：new ApplicationContext 实现类，并加载指定的配置文件

注册/注入对象到容器中：执行包扫描（包 包括 包本身以及所有子包），带有Spring框架提供的4个注解的类，并注入到容器里（@Controller 、 @Service 、 @Repository 、 @Component ）

注入依赖关系：如果Bean对象需要使用其它Bean对象作为属性，可以使用@Autowired 、 @Resource 注解

注册/注入对象到容器中

在被扫描到的位置创建类，并添加注解（@Controller 、@Service、@Repository、@Component）。此时就会注册一个bean对象注入到容器中，id/名称为类名（首字母小写）

@Repository
public class Login {
    
}

定义好bean对象后，注入到容器中，就可以获取bean对象了，在启动类APP里就可以通过类型/类名来获取这个对象(在关闭容器前)。使用类型来获取对象时，就要求容器中只有一个当前类型的对象。

	//通过类型获取
    Login l1 = context.getBean(Login.class);
    //通过类名获取
    Login l2 = (Login) context.getBean("login");

---

也可以使用@Bean注解来实现注册/注入Bean对象，@Bean注解添加在方法上，这个方法所在的类必须要能被扫描到（使用了Spring注解）。注册/注入Bean对象的名称/id为方法名。使用@Bean注解注册的对象只能使用id来获取对象，不可以使用类型来获取（报错）

@Repository
public class Login {
    @Bean
    public DemoBean d1() {
        DemoBean d1 = new DemoBean();
        d1.setName("lit");
        d1.setAge(18);
        return d1;
    }
    @Bean
    public DemoBean d2() {
        DemoBean d1 = new DemoBean();
        d1.setName("lit-2");
        d1.setAge(11);
        return d1;
    }
}

在启动类里执行：

        DemoBean d1 = (DemoBean) context.getBean("d1");
        DemoBean d2 = (DemoBean) context.getBean("d2");

        System.out.println(d1.toString());
        System.out.println(d2.toString());

---

注册配置类
一般来说，配置类是提供需要注册到容器中的对象（初始化配置工作）。用来自定义配置某些资源
在类被扫描时，使用@Configuration注解，可以注册一个配置类到容器中。

---

FactoryBean接口
接口中有三个方法：getObject() 返回对象实例，getObjectType()返回对象类型，isSingleton()返回对象是否为单例
使用如下：

@Component
public class Fb implements FactoryBean{
    @Override
    public Integer getObject() throws Exception {
        return 123;
    }

    @Override
    public Class<?> getObjectType() {
        return Integer.class;
    }
}

此时通过启动类来获取id为fb的对象时，获取的对象类型为Integer，并非Fb类型。如果要获取Fb类型的对象，则id应改为&fb。（与正常情况不同）

    Integer i1 = (Integer) context.getBean("fb");//获取getObject()方法返回值对象
    Fb f1 = (Fb)context.getBean("&fb");//获取实现FactoryBean接口的类对象本身
    System.out.println(i1);
    System.out.println(f1);

补充

lombok插件的配置：
打开 IDEA file -> setting -> plugins 在右侧Marketplace里搜索lombok 点击install 安装

---

DI 和 IOC 的目的都是为了降低代码耦合度

---

配置：
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>org.example</groupId>
    <artifactId>JavaEESpring</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <java.version>1.8</java.version>
        <maven.compiler.source>${java.version}</maven.compiler.source>
        <maven.compiler.target>${java.version}</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring-framework.version>5.2.10.RELEASE</spring-framework.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-framework.version}</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- 明确指定一些插件的版本，以免受到 maven 版本的影响 -->
            <plugin>
                <artifactId>maven-clean-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.8.1</version>
            </plugin>
            <plugin>
                <artifactId>maven-deploy-plugin</artifactId>
                <version>2.8.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-install-plugin</artifactId>
                <version>2.5.2</version>
            </plugin>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.2.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>3.1.0</version>
            </plugin>
            <plugin>
                <artifactId>maven-site-plugin</artifactId>
                <version>3.3</version>
            </plugin>
            <plugin>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>2.22.2</version>
            </plugin>

        </plugins>
    </build>
</project>

beans.xml 最后一行的 org.example 为包的位置 可以修改相关位置

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

    <context:component-scan base-package="org.example"/>

</beans>

App

package org.example;

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

public class App {

    public static void main(String[] args) {
    	// 根据Spring配置文件路径创建容器，应用上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        // 关闭容器
        ((ClassPathXmlApplicationContext) context).close();
    }
}

---

检查注入流程的配置：
配置好bean.xml 和 pom.xml 后 启动App类（运行类），不会报错，就表示环境配置没有问题

---

BeanFactory 与 FactoryBean 的区别
BeanFactory 是Spring容器的顶级接口
FactoryBean 是工厂Bean，本身是一个Bean，且主要是生产Bean的工厂