Spring快速入门——简介、优势、体系结构、配置文件、相关API

最新推荐文章于 2023-06-06 08:37:09 发布

周八营业的代码人

最新推荐文章于 2023-06-06 08:37:09 发布

阅读量74

点赞数

分类专栏： Spring 文章标签： spring java 后端

本文链接：https://blog.csdn.net/weixin_44320429/article/details/123244313

版权

Spring 专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Spring简介

Spring是分层的Java SE/EE应用full-stack（全栈：各层都有解决方案）轻量级开源框架，以IoC（Inverse Of Control：反转控制：反转bean的创建权）和AOP（Aspect Oriented Programming：面向切面编程）为内核。
提供了展示层SpringMVC和持久层Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

Spring的优势

方便解耦，简化开发

通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的的过渡耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更加专注于上层的应用。
AOP编程的支持

通过Spring的AOP功能，方便进行面向切面编程，许多不容易用传统OOP实现的功能可以通过AOP轻松实现
声明式事务的支持

可以将我们从单调的事务管理代码中解脱出来，通过声明方式灵活的进行事务管理，提高开发效率和质量。
方便程序的测试

可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架

Spring对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的支持。
降低JavaEE API的使用难度

Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了封装，使这些API的使用难度降低。

Spring体系结构

Spring快速入门

Spring程序开发步骤

导入Spring开发的基本包坐标

<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>5.3.16</version>
</dependency>

编写Dao接口和实现类：UserDao.java和UserDaoImpl.java
创建Spring核心配置文件：applicationContext.xml

在Spring配置文件中配置UserDaoImpl

<bean id="userDao" class="com.study.dao.impl.UserDaoImpl"></bean>

使用Spring的API获得Bean实例

// 创建ApplicationContext对象getBean
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

UserDao userDao = (UserDao) applicationContext.getBean("userDao");
userDao.save();

Spring配置文件

bean标签基本配置

用于配置对象交由Spring来创建。
默认情况下他调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功
基本属性
- id：Bean实例在Spring容器中的唯一标识
- class：Bean的全限定名称

Bean标签范围配置

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的，Bean在每次getBean()时创建
request	WEB项目中，Spring创建一个Bean的对象，将对象存入到request域中
session	WEB项目中，Spring创建一个Bean的对象，将对象存入到session域中
global session	WEB项目中，应用在Portlet环境，如果没有Portlet环境，那么globalSession相当于session

当scope的取值为singleton时
- Bean的实例化个数：1个
- Bean的实例化时机：在加载核心配置文件创建Spring容器时，实例化配置的Bean实例
- Bean的生命周期：
  - 对象创建：当应用加载，创建容器时，对象就被创建了
  - 对象运行：只要容器在，对象一直活着
  - 对象销毁：当应用卸载，销毁容器时，对象被销毁
当scope的取值为prototype时
- Bean的实例化个数：多个
- Bean的创建时机：当调用getBean()方法时实例化Bean
- Bean的生命周期：
  - 对象创建：当使用对象时，创建新的对象实例
  - 对象运行：主要对象在使用中，就一直活着
  - 对象销毁：当对象长时间不使用，被Java的gc垃圾回收器回收

Bean生命周期配置

init-method：指定类中的初始化方法名称
destroy-method：指定类中销毁方法名称

<bean id="userDao" class="com.study.dao.impl.UserDaoImpl" scope="prototype" init-method="init" destroy-method="destroy"></bean>

Bean实例化三种方法

无参构造方法实例化

package com.study.dao.impl;

import com.study.dao.UserDao;

public class UserDaoImpl implements UserDao {
    public UserDaoImpl() {
        System.out.println("UserDaoImpl对象创建...");
    }

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

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

    public void save() {
        System.out.println("userDao save running...");
    }
}

<bean id="userDao" class="com.study.dao.impl.UserDaoImpl" scope="prototype" init-method="init" destroy-method="destroy"></bean>

工厂静态方法实例化

package com.study.factory;

import com.study.dao.UserDao;
import com.study.dao.impl.UserDaoImpl;

public class StaticFactory {
    public static UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

<!--工厂静态方法实例化，因为是静态方法，所以不需要创建工厂对象，可以直接通过类名调用方法获得bean-->
<bean id="UserDao" class="com.study.factory.StaticFactory" factory-method="getUserDao"></bean>

工厂实例方法实例化

package com.study.factory;

import com.study.dao.UserDao;
import com.study.dao.impl.UserDaoImpl;

public class DynamicFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}

<!--先实例化工厂-->
<bean id="factory" class="com.study.factory.DynamicFactory"></bean>
<!--再通过工厂对象来调用getUserDao()方法获得bean-->
<bean id="UserDao" factory-bean="factory" factory-method="getUserDao"></bean>

Bean的依赖注入分析

目前UserService实例和UserDao实例都存在于Spring容器中，当前的做法是在容器外部获得UserService实例和UserDao实例，然后在程序中进行结合。
因为UserService和UserDao都在Spring容器中，而最终程序直接使用的是UserService，所以可以在Spring容器中，将UserDao设置到UserService内部。
Bean的依赖注入概念
- 依赖注入（Dependency Injection）：他是Spring框架核心IOC的具体实现
- 在编写程序时，通过控制反转把对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。IOC解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
- 那这种业务层和持久层的依赖关系，在使用Spring之后，就让Spring来维护了。简单来说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

Bean的依赖注入方式

怎么把UserDao注入到UserService内部呢？

构造方法

package com.study.service.impl;

import com.study.dao.UserDao;
import com.study.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {
    private UserDao userDao;

	//通过set方法注入UserDao对象
    /*public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }*/

    /*构造方法实现bean的注入*/
    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    public UserServiceImpl() {
    }

    public void save() {
        /*
        通过set方法注入UserDao，就可以不用通过容器获取了
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        */
        userDao.save();
    }
}

<!--通过有参构造方法实现bean的注入-->
<bean id="userService" class="com.study.service.impl.UserServiceImpl">
    <!--name的userDao指的是构造函数的参数名，ref的userDao指的是引用容器中的bean的id-->
    <constructor-arg name="userDao" ref="UserDao"></constructor-arg>
</bean>

set方法

package com.study.service.impl;

import com.study.dao.UserDao;
import com.study.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserServiceImpl implements UserService {
    private UserDao userDao;

//    通过set方法注入UserDao对象
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    public void save() {
        /*
        通过set方法注入UserDao，就可以不用通过容器获取了
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        */
        userDao.save();
    }
}

<!--用Spring产生UserService-->
<bean id="userService" class="com.study.service.impl.UserServiceImpl">
    <!--通过set方法注入UserDao对象给UserService-->
    <!--其中name的值是set方法的名字且小写开头，如setUserDao()，则对应的name="userDao"-->
    <!--通过ref把上面的UserDao bean注入到UserService中-->
    <property name="userDao" ref="UserDao"></property>
</bean>

package com.study.controller;

import com.study.service.UserService;
import com.study.service.impl.UserServiceImpl;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {
    public static void main(String[] args) {

        /*//普通的获取UserService对象的方法
        UserService userService = new UserServiceImpl();
        userService.save();*/

        /*
        * 让spring容器创建bean后，通过ApplicationContext对象获取对象，从而调用对象的方法
        */
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserService userService = (UserService) applicationContext.getBean("userService");
        userService.save();

        /*
        * 以下方法创建UserService对象后调用save()方法会报错（空指针）
        * 因为这个UserService对象不是从容器拿的，它的内部没有UserDao对象
        * 在UserService的save()方法中调用UserDao的save()方法就会报错
        * */
        /*UserService userService1 = new UserServiceImpl();
        userService1.save();*/
    }
}

P命名空间注入：本质也是set方法注入，但比起上述的set方法注入更加方便，主要体现在配置文件中。首先，需要引入P命名空间：
```
xmlns:p="http://www/springframework.org/schema/p"
```

其次，需要修改注入方式

<bean id="userService" class="com.study.service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

Bean的依赖注入的数据类型

上面的操作，都是注入的引用Bean，除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。

注入数据的三种数据类型

普通数据类型
引用数据类型

就是前面的怎么把UserDao注入到UserService内部。

集合数据类型

package com.study.pojo;

public class User {
    private String name;
    private String addr;

    public String getName() {
        return name;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", addr='" + addr + '\'' +
                '}';
    }
}

package com.study.dao.impl;

import com.study.dao.UserDao;
import com.study.pojo.User;

import java.util.List;
import java.util.Map;
import java.util.Properties;

public class UserDaoImpl implements UserDao {
    private String username;
    private int age;

    private List<String> stringList;
    private Map<String, User> userMap;
    private Properties properties;

    /*普通数据类型的注入*/
    public void setUsername(String username) {
        this.username = username;
    }

    public void setAge(int age) {
        this.age = age;
    }

    /*集合数据类型的注入*/
    public void setStringList(List<String> stringList) {
        this.stringList = stringList;
    }

    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    
    public void save() {
        System.out.println(username+"-------"+age);

        System.out.println(stringList);
        System.out.println(userMap);
        System.out.println(properties);

        System.out.println("userDao save running...");
    }
}

<bean name="userDao" class="com.study.dao.impl.UserDaoImpl">
    <!--注入普通数据类型-->
    <!--ref：代表对象引用；value：代表普通属性值-->
    <property name="username" value="rose"/>
    <property name="age" value="20"/>

    <!--注入集合数据类型-->
    <property name="stringList">
        <list>
            <!--定义的List<String>
                    String属于普通数据类型，所以里面使用value标签
                -->
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>

    <property name="userMap">
        <map>
            <!--定义的Map<String,User>，
                    其中String属于普通数据类型，使用key；
                    User属于引用数据类型，使用value-ref，注意：被引用对象必须存在容器当中
                -->
            <entry key="user1" value-ref="user1"></entry>
            <entry key="user2" value-ref="user2"></entry>
        </map>
    </property>

    <property name="properties">
        <props>
            <prop key="prop1">prop1Content</prop>
            <prop key="prop2">prop2Content</prop>
            <prop key="prop3">prop3Content</prop>
        </props>
    </property>
</bean>

<bean id="user1" class="com.study.pojo.User">
    <property name="name" value="lisa"/>
    <property name="addr" value="Koran"/>
</bean>

<bean id="user2" class="com.study.pojo.User">
    <property name="name" value="jisoo"/>
    <property name="addr" value="Koran"/>
</bean>

引入其他配置文件（分模块开发）

实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载

<import resource="applicationContext-xxx.xml"/>

Spring的配置要点总结

<bean>标签
	id属性：在容器中Bean实例的唯一标识，不允许重复
	class属性：要实例化的Bean的全限定名
	scope属性：Bean的作用范围，常用是Singleton（默认）和prototype
	<property>标签：属性注入
		name属性：属性名称，set方法的名字且小写开头
		value属性：注入的普通属性值
		ref属性：注入的对象引用值
		<list>标签
		<map>标签
		<properties>标签
    <constructor-arg>标签：通过有参构造方法实现注入
<import>标签：导入其他的Spring的分文件

Spring相关API

ApplicationContext的继承体系

applicationContext：接口类型，代表应用上下文，可以通过实例获得Spring容器中的Bean对象

ApplicationContext的实现类

ClassPathXmlApplicationContext：他是从类的根路径下加载配置文件，推荐使用这种
FileSystemXmlApplicationContext：他是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置
AnnotationConfigApplicationContext：当使用注解配置容器对象时，需要使用此类来创建Spring容器，他用来读取注解

getBean()方法使用

其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean的实例，返回时Object，需要强转。
当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。

知识要点

Spring的重点API

ApplicationConetxt app = new ClassPathXmlApplicationContext("xml文件");
app.getBean("id");
app.getBean(Class);

周八营业的代码人

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring快速入门——简介、优势、体系结构、配置文件、相关API

Spring简介Spring是分层的Java SE/EE应用full-stack（全栈：各层都有解决方案）轻量级开源框架，以IoC（Inverse Of Control：反转控制：反转bean的创建权）和AOP（Aspect Oriented Programming：面向切面编程）为内核。提供了展示层SpringMVC和持久层Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。
复制链接

扫一扫