Spring学习笔记（一）

大梦谁先觉i

已于 2022-03-16 21:11:52 修改

阅读量122

点赞数

分类专栏： Spring 文章标签： spring java 学习

于 2022-03-09 23:04:25 首次发布

本文链接：https://blog.csdn.net/qq_45228323/article/details/117715533

版权

Spring 专栏收录该内容

19 篇文章 3 订阅

订阅专栏

1. spring概述

1.1 框架概述

框架是一个封装了很多功能和模块的程序的半成品。

可以理解为是一个由很多工具类组合而成的一个工具包。

1.2 Spring是什么

Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架。是Java开发的灵魂框架。

Spring有两大内核：

IOC（Inverse Of Control：控制反转）

AOP（Aspect Oriented Programming：面向切面编程）

1.3 Spring功能

IOC：控制反转，其实就是把对象的创建权，交给spring，由Spring负责给我们创建对象

DI：   依赖注入，其实就是给对象的成员变量赋值。

AOP：面向切面编程，底层就是动态代理

事务： Spring提供了声明式事务，也就是说，我们可以通过配置的方式来添加事务。

2 入门案例

2.1 Spring程序开发步骤

①导入 Spring 开发的基本包坐标（5.1.9.release）

②编写业务层与表现层

③创建Spring核心配置文件

④在 Spring 配置文件中配置要创建的对象

⑤通过spring获取资源(获取创建的对象)

2.2 案例实现

① 导入坐标

<!--spring核心-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

② 编写业务层与表现层

//service接口
public interface UserService {
	//业务方法  
	void save();
}

//service实现类
public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("user service running...");
    }
}

③ 创建Spring核心配置文件,并配置

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!-- 1.创建spring控制的资源(让spring帮忙创建该类的对象)-->
    <bean id="userService" class="com.shuai.service.impl.UserServiceImpl"/>
    
</beans>

④ 通过spring获取资源(获取创建的对象)

public class UserApp {
    public static void main(String[] args) {
        //加载配置文件
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //获取资源
        UserService userService = (UserService) ctx.getBean("userService");
        //调用方法
        userService.save();
    }
}

3 IOC配置-XML格式

3.1 Bean标签基本配置

作用：定义spring中的资源，受此标签定义的资源将受到spring控制

格式:

<beans>
	<bean 属性名="属性值" ></bean>
</beans>

3.2 常见属性

属性名	说明
id	Bean实例在Spring容器中的唯一标识，通过id值获取bean
class	Bean的类型, spring创建的就是该类的对象
name	Bean的名称，可以通过name值获取bean，用于多人配合时给bean起别名

3.3 其他属性

3.3.1 scope

作用：定义bean的作用范围
格式：

<bean scope="singleton"></bean>

取值：
- singleton：设定创建出的对象保存在spring容器中，是一个单例的对象,
- prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象
- request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置

3.3.2 生命周期

名称：init-method，destroy-method
作用：定义bean对象在初始化或销毁时完成的工作
格式：

<bean init-method="bean初始化时执行的方法" destroy-method="bean销毁时执行的方法"></bean>

注意事项：
- 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次
- 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建时均执行一次
- 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次
- 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行

3.4 对象创建方式

1）使用无参构造方法实例化

默认调用无参构造方法创建对象，如果bean中没有默认无参构造函数，将会创建失败

 <!--相当于: UserDao userDao = new UserDaoImpl();-->
    <bean id="userDao" class="com.shuai.dao.impl.UserDaoImpl"/>

2）工厂静态方法实例化

工厂静态方法实例化, 指的是在创建对象的时候,是通过调用某个类的静态方法才能创建对象.

例如:

	LocalDate now = LocalDate.now();

//工厂类
public class StaticFactoryBean {
    //静态方法，通过该方法获取对象
    public static UserDao createUserDao(){    
    	return new UserDaoImpl();
    }
}

<!-- 调用StaticFactoryBean类的静态方法createUserDao获取对象 -->
<!--相当于: UserDao userDao = StaticFactoryBean.createUserDao();-->
<bean id="userDao" class="StaticFactoryBean" factory-method="createUserDao"></bean>

3）工厂实例方法实例化

工厂实例方法实例化, 指的是在创建对象的时候, 需要通过其他类的对象才能创建对象.

例如:

LocalDate now = LocalDate.now();

	DayOfWeek dfw = now.getDayOfWeek();

//工厂类
public class DynamicFactoryBean {  
    //非静态方法，需要先创建工厂类的对象，再通过对象调用该方法，获取对象
	public UserDao createUserDao(){        
		return new UserDaoImpl(); 
	}
}

<!-- 创建工厂类的对象 -->
<!-- 相当于: DynamicFactoryBean factoryBean = new DynamicFactoryBean(); -->
<bean id="factoryBean" class="com.test.factory.DynamicFactoryBean"/>
<!-- 通过工厂类的对象，调用createUserDao方法，获取UserDao对象 -->
<!-- 相当于: UserDao userDao =  factoryBean.createUserDao(); -->
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao">
    <constructor-arg name="参数名" value="参数值"/>
</bean>

4. 依赖注入-DI

4.1 概述

依赖注入（Dependency Injection）：是SpringIOC的具体体现，简单来说，就是给对象的属性赋值

4.2 Bean的依赖注入方式

4.2.1 Set方法赋值(常用)

①在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
    private UserDao userDao;
 
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;  
    } 
    
    @Override    
    public void save() {      
   		 userDao.save();
	}
}

②配置Spring容器调用set方法进行注入

<bean id="userDao" class="com.shuai.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.shuai.service.impl.UserServiceImpl">
    <!-- 使用setUserDao方法，把userDao对象，注入userService中 -->
	<property name="userDao" ref="userDao"/>
</bean>

4.2.2 构造方法赋值

①在类中提供有参构造

public class UserServiceImpl implements UserService {	
    private UserDao userDao;

    public UserServiceImpl(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
 }

②配置Spring容器调用有参构造时进行注入

  <bean id="userDao" class="com.test.dao.impl.UserDaoImpl"/>
    <bean id="userService" class="com.shuai.service.impl.UserServiceImpl">
        <!-- 使用构造方法，把userDao对象，注入userService中 -->
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>
    </bean>

4.3 集合类型数据注入

1) list

<property name="al">
    <list>
        <value>itheima</value>
        <value>66666</value>
        <!--如果集合元素是对象,则可以注入对象(直接创建新对象)-->
        <bean class="com.test.domain.User"/>
        <!--如果集合元素是对象,则可以注入对象(引入已经创建的对象)-->
        <ref bean="u1"/>
    </list>
</property>

2) rops

 <property name="properties">
        <props>
            <prop key="name">test666</prop>
            <prop key="value">666666</prop>
        </props>
    </property>

3) array

<property name="arr">
        <array>
            <value>123456</value>
            <value>66666</value>
        </array>
    </property>

4) set

<property name="hs">
     <set>
         <value>test</value>
         <value>66666</value>
     </set>
</property>

5) map

 <property name="hm">
        <map>
            <entry key="name" value="test66666"/>
            <entry key="value" value="6666666666"/>
        </map>
    </property>

5 其他

5.1 引入properties文件

语法:

<context:property-placeholder location="classpath:filename.properties">

获取数据:

<property name="propertyName" value="${propertiesName}"/>

注意：如果需要加载所有的properties文件，可以使用*.properties表示加载所有的properties文件
注意：读取数据使用${propertiesName}格式进行，其中propertiesName指properties文件中的属性名

5.2 引入其他配置文件

如果当前项目有多个配置文件, 则可以:

1.在主配置文件中引入其他配置文件

2.在加载时,直接加载多个配置文件

引入其他配置文件

<import resource="被引入配置文件的路径"/>

直接加载多个配置文件

new ClassPathXmlApplicationContext("config1.xml","config2.xml");

注意:

同id的bean，后定义的覆盖先定义的
导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置
导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

5.3 ApplicationContext对象的获取

//加载配置文件，获取Spring核心容器
ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");

//加载配置文件，获取Spring核心容器, 一般不用
ApplicationContext ac2 = new FileSystemXmlApplicationContext("配置文件绝对路径");

//加载配置类, 获取Spring核心容器, 用于注解开发
ApplicationContext ac3 = new AnnotationConfigApplicationContext(配置类.class);

5.4 实例对象的获取

   //加载配置文件，获取Spring核心容器
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    
    //获取Spring核心容器中,id叫做"userService"的对象
    UserService userService = (UserService)ac.getBean("userService");
    //获取Spring核心容器中,类型是"UserService"的对象
    UserService userService = ac.getBean(UserService.class);
    //获取Spring核心容器中,,id叫做"userService"的,类型是"UserService"的对象
    UserService userService = ac.getBean("userService",UserService.class);

大梦谁先觉i

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring学习笔记（一）

1. spring概述1.1 框架概述框架是一个封装了很多功能和模块的程序的半成品。可以理解为是一个由很多工具类组合而成的一个工具包。1.2 Spring是什么Spring是分层的 Java SE/EE应用 full-stack 轻量级开源框架。是Java开发的灵魂框架。Spring有两大内核：IOC（Inverse Of Control：控制反转）AOP（Aspect Oriented Programming：面向切面编程）1.3 Spring功能IOC：控制反转，其实就是把对象的
复制链接

扫一扫