Spring的使用开始

什么事 ？ Spring

一个能够容下其他框架的java框架。基于IOC控制反转和反射，来管理java中的对象。这样做省去了很多前期编写，后期维护的复杂。凭着这些优点霸占了Java EE开发的半壁江山。

看这个教程的你，之前就应该会的：

• idea的使用

• java基础（至少学完面向对象和常用实用类）

• maven的使用

• java servlet使用

• mysql数据库和表的增删改查操作

• html、css、js、ajax的使用

我用的环境是

windows 11
idea 2022.1
jdk 18.0.2

‍

先开用 ！Spring

用Maven吧，这样方便的多。另外，孤山想导进去一些多余的东西，后期用spring整合，因为spring是个缝合怪，什么都能放进去，现在的Spring Boot就是大家爱用的整合，因为像速食面一样开袋即食，在这个工具理性居多的世界。

<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>study</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>war</packaging>
​
  <name>study3</name>
  <url>http://maven.apache.org</url>
​
  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <maven.compiler.source>18</maven.compiler.source>
    <maven.compiler.target>18</maven.compiler.target>
  </properties>
<!--测试-->
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
​
<!--javaweb-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.0.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
      <scope>provided</scope>
    </dependency>
​
​
<!--图形界面-->
    <dependency>
      <groupId>org.openjfx</groupId>
      <artifactId>javafx-controls</artifactId>
      <version>18</version>
    </dependency>
    <dependency>
      <groupId>org.openjfx</groupId>
      <artifactId>javafx-fxml</artifactId>
      <version>18</version>
    </dependency>
​
<!--spring框架基本-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.21</version>
    </dependency>
<!--mysql数据库-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.30</version>
    </dependency>
<!--json与对象互相转换-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>fastjson</artifactId>
      <version>1.2.67_noneautotype2</version>
    </dependency>
<!--xml框架-->
    <dependency>
      <groupId>org.dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>2.1.3</version>
    </dependency>
<!--数据库框架-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.6</version>
    </dependency>
​
<!--token生成-->
    <dependency>
      <groupId>com.auth0</groupId>
      <artifactId>java-jwt</artifactId>
      <version>3.18.2</version>
    </dependency>
  </dependencies>
​
</project>

现在可以使用了，先编写一个用户类，放在pojo包下。

package pojo;
public class user {
    private int id;
    private String name;
​
    public int getId() {
        return id;
    }
​
    public void setId(int id) {
        this.id = id;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
}

在resources目录下新建bean.xml文件，为什么要在这个目录？因为非java代码都要放在这里。。。最后编译的时候都会放在一个地方。

注意看这个bean，class属性是类所在的位置，按package的写法写上就行，id是这个类的唯一名字。bean里面的property对应这里面的变量初始值，name是变量名，value是变量值。

<?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-3.0.xsd">
    <bean id="user" class="pojo.user">
        <property name="id" value="10001" />
    <property name="name" value="孤山" />
    </bean>
</beans>

写测试类

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.user;
​
public class test {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
        user obj = context.getBean("user",user.class);
        System.out.println(obj.getId());
        System.out.println(obj.getName());
    }
}

没写错的话，你会看到控制台输出了10001和孤山。

‍

背后思想

Ioc控制反转

想必你发现了一件事情，我们没有用new去获取user对象的实例，就获得了user对象，因为spring已经帮我们实例化了，这种将管理对象交给容器的行为，称为控制反转。放在容器里的一个个对象，称为bean。

以前想使用对象的时候，必须new Object()去创建，直接是创建者与被创建者的关系。想要什么对象必须主动出击。而现在new都不用new了，对对象的控制权也不在我们手里。

依赖注入

然而，只是说控制反转似乎看不出什么好处，于是又提出了依赖注入，在面向对象中，对象直接有依赖的关系。比如有一个叫做B的类。

public class B {
    String bid;
    A a;
}

B中有一个A类型的对象a，就可以说B依赖于A，而依赖注入就是依据这类关系出现的。spring会根据依赖关系在创建对象的时候把依赖注入到目标类中，从而减小耦合。

目前不讲太多原理，做了大量实践后，学习原理自然会变得容易。

‍

两种IOC容器

BeanFactory

是IOC容器的基本实现，大概只知道造bean，这家伙也很懒，等到程序要使用时才加载对象，一般开发不会用到它。

把上面的例子中的测试类改写。

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import pojo.user;
​
​
​
public class test {
    public static void main(String[] args) {
            BeanFactory context = new ClassPathXmlApplicationContext("Beans.xml");
            user obj = context.getBean("user", user.class);
            System.out.println(obj.getId());
            System.out.println(obj.getName());
    }
}

ApplicationContext

比BeanFactory多了许多功能，面向切面、国际化、事务支持什么的，要用的类也都提前加载，以后要一直用它。。。

目前已知的情报

Bean.xml

‍