Spring初始

Posted 2022-11-05 秃头小宝儿

一、Spring简介

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

（一）Spring生态（二）SpringFramework 子模块简介

Spring专注于为 Java 企业应用提供一站式的开发框架，目的是让 Java 企业开发更加便捷，安全与高效。 Spring Framework 属于其中最基础，最核心的部分，Spring下的其他大部分框架都依赖 Spring Framework 。

（三）Core Container（核心容器）

（1）IOC(控制反转)

控制反转是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。只是因为该理论时间成熟相对较晚，并没有包含在GoF中。一种设计思想，使用它可以实现解耦。将对象创建和消耗的权利交给IOC框架进行管理。

（2）DI(依赖注入)

DI (Dependency Injection，依赖注入) 是实现IoC的方法之一。所谓依赖注入，就是由IOC容器在运行期间，动态地将某种依赖关系注入到对象之中。IOC控制反转属于设计思想，而DI依赖注入属于实现IOC思想的技术。

（四）Spring容器的使用流程

Spring容器的API有 BeanFactory（功能少） 和 ApplicationContext（功能多） 两大类，他们都是顶级接口。其中ApplicationContext 是 BeanFactory 的子接口。对于两者的说明请参考面试题讲解Spring容器部分。我们主要使用 ApplicationContext 应用上下文接口。

（五）开发步骤

（1）准备Maven项目及环境

首先创建一个Maven项目，名称为xxx，以下是项目的maven配置文件 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>springdemo one</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>

</project>

（2）准备启动入口类

写入一个入口类：

package org.example;

import org.example.config.MyAppConfig;
import org.example.controller.LoginController;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * @Author: XiShanShan
 * @Description:
 * @Date:Created in 17:00 2022/3/8
 * @Modified By:xss666
 */
public class App 
    public static void main(String[] args) 
        // ApplicationContext --顶级父类（上下文中存储着各种对象）
       ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");

        LoginController loginController= (LoginController) context.getBean("loginController");
        System.out.println(loginController);
        //关闭资源
        ((ClassPathXmlApplicationContext)context).close();
    

（3）准备Spring配置文件beans.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
        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>

（六）初始化/注册Bean

（1）注册Bean的方式一：类注解

在类上使用注解 @Controller ,@Service ,@Repository ,@Component 。需要保证该类会被Spring扫描到，这种定义方式默认会注册一个名称为类名首字母小写的Bean对象到容器中。

package org.example.dao;
import org.example.model.User;
import org.springframework.stereotype.Repository;
@Controller
public class LoginController 

定义好了Bean对象，注册到容器中以后，就可以获取Bean对象了，在入口类 org.example.App 中，可以通过 ApplicationContext 对象获取Bean，有两种方式获取：

• 通过类型获取：这种获取方式要求该类型的Bean只能有一个
• 通过名称获取：同一个类型的Bean可以有多个

public static void main(String[] args) 
        // ApplicationContext --顶级父类（上下文中存储着各种对象）
       ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
         
        LoginController loginController= (LoginController) context.getBean("loginController");
        System.out.println(loginController);

        LoginController loginController1=context.getBean(LoginController.class);
        System.out.println(loginController1);
        //关闭资源
        ((ClassPathXmlApplicationContext)context).close();
        

（2）注册Bean的方式二：@Bean

当前类被 Spring 扫描到时，可以在方法上使用 @Bean 注解，通过方法返回类型，也可以定义、注册Bean对象，默认使用方法名作为Bean的名称。

package org.example.model;
import lombok.Data;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
//@Getter
//@Setter
//@ToString
@Data
public class User 
    private String name;
    private String password;

public class LoginController 
@Bean
    public User user1()
        User user1=new User();
        user1.setName("孙悟空");
        user1.setPassword("hello,孙悟空");
        return user1;
    
    @Bean
    public  User user2()
        User user2=new User();
        user2.setName("猪八戒");
        user2.setPassword("hello,猪八戒");
        return user2;
    
  

public class App 
    public static void main(String[] args) 
        // ApplicationContext --顶级父类（上下文中存储着各种对象）
       ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
       //方法一：getBean()方法
        User user1= (User) context.getBean("user1");
        System.out.println(user1);

        //方法二：不用强转getBean("user2",User.class)
        User user2=context.getBean("user2",User.class);
        System.out.println(user2);
        
    

（3）注册Bean的方式三：@Configuration

package org.example.config;

import org.springframework.context.annotation.Configuration;

@Configuration
public class MyAppConfig 

在App里面调用

public class App 
    public static void main(String[] args) 
        // ApplicationContext --顶级父类（上下文中存储着各种对象）
       ApplicationContext context=new ClassPathXmlApplicationContext("beans.xml");
       
       MyAppConfig appConfig=context.getBean(MyAppConfig.class);
       System.out.println(appConfig);
        //关闭资源
        ((ClassPathXmlApplicationContext)context).close();
        
    

（七）依赖注入（依赖装配）

从Spring容器中获取对象的方式有三种：

• 第一种：属性注入 @Autowired
• 第二种：setter 注入: setter+@Autowired
• 第三种：构造方法注入

package org.example.service;

import org.springframework.stereotype.Service;

@Service
public class LoginService 
    public void Hello()
        System.out.println("LoginService sayHi");
    

package org.example.controller;
import lombok.Data;
import org.example.model.User;
import org.example.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Controller
//@Service
//@Repository
//@Component
@Data
public class LoginController 
    //第一种类注解的方式：属性注入
    @Autowired
   // private LoginService loginService;

    //第二种注解方式：Set注入
//    private LoginService loginService;
//    @Autowired
//    public void setLoginService(LoginService loginService)
//        this.loginService=loginService;
//    

    //第三种：构造函数注入
    private LoginService loginService;
    public LoginController(LoginService loginService)
        this.loginService=loginService;
    

    public void sayHi()
//        loginService =new LoginService();
        loginService.Hello();