spring 框架项目怎么运行 spring框架使用

转载

mob64ca13fba42b 2024-04-03 09:30:05

文章标签 spring 框架项目怎么运行 spring User 创建对象 文章分类 架构后端开发

1. Spring框架的作用

Spring框架的主要作用是创建对象和管理对象。

创建对象：类似于User user = new User();

管理对象：随时可以通过Spring框架获取对象，甚至Spring框架还能够帮我们为对象的属性进行赋值等。

2. 通过Spring框架创建对象，并获取对象

在Eclipse中创建Maven Project，在创建过程中勾上Create a simple project，Group Id填为cn.tedu，Artifact Id填为spring01。

如果某个项目不会被其它项目所使用，只需要保证自身能独立运行，其实Group Id和Artifact Id的值是多少，并不重要。

创建成功后，先在pom.xml中添加以上配置：

<properties>
    <java.version>1.8</java.version>
    <maven.compiler.source>1.8</maven.compiler.source>
    <maven.compiler.target>1.8</maven.compiler.target>
</properties>

然后，对项目名称点击鼠标右键，选择Maven > Update Project以更新Maven，则当前环境会使用Java 1.8。

接下来，需要在pom.xml中添加Spring框架所需的spring-context依赖的代码：

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.6.RELEASE</version>
    </dependency>
</dependencies>

如果需要Spring管理某个类的对象，可以通过自定义的类进行配置！

例如存在需求：使得Spring框架管理Date类的对象！

先在项目的cn.tedu.spring包中创建Beans类，并且，在这个类中自定义方法，方法的返回值类型必须是Date，然后，自行在方法体中创建出Date对象并返回即可：

package cn.tedu.spring;

import java.util.Date;

import org.springframework.context.annotation.Bean;

public class Beans {
	
	@Bean
	public Date aaa() {
		return new Date();
	}

}

以上使用的包名是自定义，并不是强制要求。
以上使用的类名是自定义，并不是强制要求。

关于以上自定义的方法：

应该使用public权限；
返回值类型是需要Spring管理的对象所归属的类型；
方法名称可以自定义；
参数列表暂时为空；
必须添加@Bean注解。

然后，就可以创建一个用于运行的类，加载以上类，并获取对象：

package cn.tedu.spring;

import java.util.Date;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Demo {
	
	public static void main(String[] args) {
		// 1. 加载配置类，获取Spring容器
		AnnotationConfigApplicationContext ac
			= new AnnotationConfigApplicationContext(Beans.class);
		
		// 2. 从Spring容器中获取对象
		Date date = (Date) ac.getBean("aaa"); // getBean()方法的参数，就是配置对象的方法的名称
		
		// 3. 测试
		System.out.println(date);
		
		// 4. 关闭
		ac.close();
	}

}

运行以上代码，就可以看到输出的对象！

在以上Beans类中，配置对象的方法名是aaa，在运行的Demo类中，调用getBean()方法的参数也必须是"aaa"，名称必须保持一致！

通过，获取某个值的方法的名称都应该是getXxx，所以，以上Beans类中的方法应该改为：

@Bean
public Date getDate() {
    return new Date();
}

但是，一旦将方法名改成了getDate，运行时，调用的getBean()方法的参数也应该改成getDate，例如改成：

Date date = (Date) ac.getBean("getDate");

很显然，这个getDate表示的是一个名称，而名称应该使用名词，而不应该使用动词作为前缀！

如果要解决这个问题，可以在@Bean注解中配置参数，例如：

@Bean("date")
public Date getDate() {
    return new Date();
}

后续，在运行时，调用getBean()方法的参数就是@Bean注解中配置的值，例如：

Date date = (Date) ac.getBean("date");

小结：在运行时，调用的getBean()方法的参数值，默认情况下，是配置对象的方法的名称，如果配置对象的方法的@Bean注解添加了参数，则getBean()方法的参数就是@Bean注解中的参数！

其实，Spring推荐直接使用名词作为以上配置对象的方法名称，即推荐使用date作为方法名，而不是getDate作为方法名！该名词将用于getBean()方法的参数，毕竟这个方法定义好了以后，是由Spring框架去调用了，开发人员不需要自行调用该方法，为了简化代码的同时还保证getBean()代码的语义，推荐使用名词作为方法名称！

3. 由Spring管理的对象的作用域

由Spring管理的对象，在默认情况下，都是单例的！如果在配置对象的方法之前，补充添加@Scope注解，且注解参数配置为prototype时，就不是单例的了！例如：

@Bean
@Scope("prototype")
public User user() {
    return new User();
}

注意：Spring与单例模式是两个不同的概念！
当需要同时使用多个注解时，各注解不区分先后顺序。

由Spring管理的对象，在单例的情况下，默认是饿汉式的！如果希望调整为懒汉式的，则在配置对象方法的方法之前补充添加@Lazy注解即可：

@Bean
@Lazy
public User user() {
    return new User();
}

4. 由Spring管理的对象的生命周期

生命周期：某个对象从创建到最终销毁会经历的历程！

通常，需要讨论生命周期时，对应的数据类型的对象都不是由开发人员自行维护的！

被容器维护的对象，都是由容器创建对象，并在适当的时候调用其中的某些方法的！而开发人员需要做的就是“确定满足某条件的时候应该执行什么任务”！也就是说，“容器决定什么时候执行，开发人员决定执行时做什么”。

学习生命周期的意义就是“知道在什么时候需要做什么事情”！

以Servlet为例，其生命周期中会有几个特殊的方法，在特定的情况下会被调用，这些就称之为生命周期方法：

init()：当Servlet被创建对象后，立即执行，且只执行1次，该方法适合编写一些初始化相关的代码；
service()：当接收到匹配的请求后会被调用，接收到多少次请求，就执行多少次该方法；
destroy()：当Servlet对象即将被销毁之前执行，且只执行1次，该方法适合编写一些与结束相关的代码，例如关闭等等。

当使用Spring框架后，某些类的对象交给Spring框架来管理了，那么，这些对象在什么时候被创建、什么时候被销毁，及创建过程和销毁过程中需要执行某些代码，对于开发人员来说，一定程度上是不可控的！

Spring框架允许用户在类中自定义最多2个方法，分别表示“初始化方法”和“销毁方法”，并且，Spring框架会在创建对象之后自动调用初始化方法，会在销毁对象之前调用销毁方法！关于方法的定义：

访问权限：应该使用public权限；
返回值类型：使用void；
方法名称：自定义；
参数列表：空。

例如，在User类中自定义2个生命周期方法：

public void init() {
    System.out.println("User.init()");
}

public void destroy() {
    System.out.println("User.destroy()");
}

然后，在配置对象的方法之前的@Bean注解中配置这2个方法作为生命周期方法：

@Bean(initMethod="init", destroyMethod="destroy")
public User user() {
    return new User();
}

5. 通过组件扫描使得Spring管理类的对象

假设存在User类，需要被Spring框架创建并管理对象，则，必须先明确User类所在的包，然后，在用于运行的类Demo中，在AnnotationConfigApplicationContext的构造方法中，将包名作为构造方法的参数，例如：

AnnotationConfigApplicationContext ac 
    = new AnnotationConfigApplicationContext("cn.tedu.spring");

以上代码则表示“组件扫描”，当执行时，Spring框架会扫描指定的包中所有的内容，并且，自动创建各组件的对象并进行管理！

当然，并不是所有的类都是“组件”，如果要标识某个类是“组件”，必须在类的声明之前添加@Component注解！例如：

package cn.tedu.spring;

import org.springframework.stereotype.Component;

@Component
public class User {

}

后续，从Spring容器中获取对象时，默认情况下，将类名的首字母改为小写，作为Bean的名称，用于调用getBean()方法的参数，例如：

User user = ac.getBean("user", User.class);

关于Bean的名称，如果类名首字母是大写，且第2个字母是小写，例如User或Student，则Bean的名称就是将首字母改为小写即可，也就是user或student！如果不满足该条件，例如类名是teacher或IUserDao，则Bean的名称就是类的名称！

当然，Spring框架也允许自定义Bean的名称，只要将自定义的名称配置在@Component注解参数中即可，例如：

package cn.tedu.spring;

import org.springframework.stereotype.Component;

@Component("stu")
public class Student {
	
}

则以上类的对象被Spring管理时，Bean的名称就是"stu"，后续，调用getBean()方法获取对象时，也必须使用这个名称来获取对象：

Student stu = ac.getBean("stu", Student.class);

【附】1. 单例模式

单例模式，是设计模式中的一种。

单例模式，其特点是：被设计为单例的类型，在同一时间内，该类型的对象只会存在1个！

假设存在King类：

public class King {}

作为一个普通的类，是可以在类的外部随意创建对象的，例如：

King k1 = new King();
King k2 = new King();
King k3 = new King();

因为在King类中，没有声明构造方法，则编译器会自动的添加默认构造方法，也就是公有的、无参数的构造方法，所以，在类的外部才可以随意创建对象！以上代码中就创建了3个King类型的对象！

如果要实现单例，首先，就不能允许随意创建对象，可以显式的添加构造方法，并将其私有化，避免外部随意访问，例如：

public class King {
    private King() {}
}

一旦显式的添加了构造方法，编译器就不会再自动添加构造方法了，则在类的外部，将不可以再执行King k1 = new King();这类的代码了！

使用了私有的构造方法，并不影响在类的内部使用该构造方法，为了保证在类的外部依然可以获取类的对象，则可以：

public class King {
    private King() {}
    
    public King getInstance() {
        return new King();
    }
}

同时，为了保证“多次获取时，获取到的都是同一个对象”，则不能反复在方法中创建对象，而是改为：

public class King {
    private King king = new King();
    
    private King() {}
    
    public King getInstance() {
        return king;
    }
}

改为这样以后，无论执行多少次getInstance()方法，该方法返回的都是同一个king变量，而该变量的值只是在类被加载时赋值了1次而已，就实现了单例的效果！

当然，以上代码是矛盾的！因为，如果要调用getInstance()方法，必须先有King类型的对象，而得到King类型对象的唯一途径就是调用getInstance()方法！也就是说：不调用getInstance()方法就无法得到对象，但是，调用方法之前又必须有对象！

为了解决这个问题，可以为getInstance()方法添加static修饰符，则通过类名.方法名()的格式就可以调用方法了，不需要事先获取对象！同时，基于“被static修饰的成员不可以直接访问没被static修饰的成员”的原则，所以，全局的private King king = new King();也需要添加static修饰符：

public class King {
    private static King king = new King();
    
    private King() {}
    
    public static King getInstance() {
        return king;
    }
}

至此，简单的单例模式代码就完成了，后续，需要获取King类型的对象时，只能通过King.getInstance()得到对象，而该方法每次返回的都是同一个对象！

严格来说，以上单例模式的设计是“饿汉式”的，可以看到，在类被加载时，就直接创建了King类的对象，此时，也许并不需要获取对象，但是，也创建好了，后续，当需要对象时，直接获取即可！另外，还有“懒汉式”的单例模式，其特点就是“不到逼不得已，不创建对象”！其基础代码例如：

public class King {
    private static King king;
    
    private King() {}
    
    public static King getInstance() {
        if (king == null) {
            king = new King();
        }
        return king;
    }
}

以上代码是多线程不安全的！为了解决这个问题，可以将以上代码块添加互斥锁，例如：

public class King {
    private static King king;
    
    private King() {}
    
    public static King getInstance() {
        synchronized("java") {
            if (king == null) {
                king = new King();
            }
        }
        return king;
    }
}

一旦添加了锁，就会导致每次调用getInstance()方法时都会先锁定代码再执行，效率偏低，为了解决该问题，还可以：

public class King {
    private static King king;
    
    private King() {}
    
    public static King getInstance() {
        if (king == null) { // 判断是否有必须加锁，如果没有该判断，则效率可能偏低
            synchronized("java") {
                if (king == null) { // 判断是否有必须创建对象，如果没有该判断，则可能创建多个对象
                    king = new King();
                }
            }
        }
        return king;
    }
}

以上，就是完整的懒汉式的单例模式！

小结：单例模式的特点就是“单一实例”，表现为“同一时间内，某个类的对象只有1个”！单例模式分为“饿汉式”和“懒汉式”这2种，前者是“早早的创建出对象，随时可以获取”，后者是“不到逼不得已不会创建对象”！

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。