0
点赞
收藏
分享

微信扫一扫

spring框架学习


java 学习笔记指路
基础知识

Python转java补充知识
Java中常见的名词解释

前端

【黑马程序员pink老师前端】HTML
【黑马程序员pink老师前端】JavaScript基础大总结
【黑马程序员pink老师前端】JavaScript函数与作用域
【黑马程序员pink老师前端】JavaScript对象

数据库

【黑马程序员数据库】数据库基础大总结
【黑马程序员数据库】数据库引擎
【黑马程序员数据库】数据库索引

SQL编程

【牛客】SQL刷题篇入门篇
【牛客】SQL刷题篇进阶篇

Java 框架

spring框架学习
Mybatis-plus 快速入门
Maven基础
Zookeeper初认识
HTTP简介
Tomcat
Servlet
vue入门

目录

  • 1. 开发步骤
  • 2. 配置bean文件
  • 2.1 基本属性
  • 2.1.1 id:
  • 2.1.2 class:
  • 2.1.3 scope:
  • 2.1.4 生命周期
  • 2.1.5 实例化三种方式
  • 2.2 依赖注入
  • 2.2.1 依赖注入是什么?
  • 2.2.2 set依赖注入
  • 2.2.2.1 引用注入
  • 2.2.2.2 普通数据类型注入
  • 2.2.2.3 `List`
  • 2.2.2.4 `List`
  • 2.2.2.5 Map
  • 2.2.2.6 Properties
  • 2.2.3 P命名空间注入(本质也是set)
  • 2.2.4 构造方法引用注入
  • 2.2.5 拆解配置文件,分模块开发(import)
  • 3. 相关API
  • 3.1 ApplicationContext的实现类
  • 3.1.1 ClassPathXmlApplicationContext
  • 3.1.2 FileSystemXmlApplicationContext
  • 3.1.3 AnnotationConfigApplicationContext
  • 3.2 getBean()方法
  • 4. 配置数据源
  • 5. 注解开发
  • 6. 整合Junit
  • 6.1 原始Junit测试Spring的问题
  • 6.2 Spring集成Junit
  • 6.2.1 Spring集成Junit步骤

1. 开发步骤

spring框架学习_java


① 导spring包

② 编写 Dao 接口和实现类

③ 创建 Spring 核心配置文件

④ 在 Spring 配置文件中配置 UserDaoImpl

⑤ 使用 Spring 的 API 获得 Bean 实例

2. 配置bean文件

默认情况下它调用的是类中的无参构造函数,如果没有无参构造函数则不能创建成功。

// 重点配置
<bean>标签
	id属性:在容器中Bean实例的唯一标识,不允许重复
	class属性:要实例化的Bean的全限定名
	scope属性:Bean的作用范围,常用是Singleton(默认)和prototype
	<property>标签:属性注入
		name属性:属性名称
		value属性:注入的普通属性值
		ref属性:注入的对象引用值
		<list>标签
		<map>标签
		<properties>标签
	<constructor-arg>标签
<import>标签:导入其他的Spring的分文件

2.1 基本属性

2.1.1 id:

Bean实例在Spring容器中的 唯一 标识(所以不能有重名)

2.1.2 class:

Bean的全限定名称(包名+类名)

2.1.3 scope:

指对象的作用范围,取值如下:

spring框架学习_List_02


1.当scope的取值为singleton时

Bean的实例化个数:1个

Bean的实例化时机:当Spring核心文件被加载时,实例化配置的Bean实例

Bean的生命周期:

  • 对象创建:当应用加载,创建容器时,对象就被创建了
  • 对象运行:只要容器,对象一直活着
  • 对象销毁:当应用卸载,销毁容器时,对象就被销毁了

2.当scope的取值为prototype时
Bean的实例化个数:多个
Bean的实例化时机:当调用getBean()方法时实例化Bean

  • 对象创建:当使用对象时,创建新的对象实例
  • 对象运行:只要对象在使用中,就一直活着
  • 对象销毁:当对象长时间不用时,被 Java 的垃圾回收器回收了

2.1.4 生命周期

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

2.1.5 实例化三种方式

无参构造方法实例化

// 定义接口和类
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>

工厂静态方法实例化

// 建立静态工厂类
public class StaticFactoryBean {
	public static UserDao createUserDao(){
		return new UserDaoImpl();
	}
}

<bean id="userDao" class="com.itheima.factory.StaticFactoryBean" 
factory-method="createUserDao" />

工厂实例方法实例化(非静态)

public class DynamicFactoryBean {
	public UserDao createUserDao(){
		return new UserDaoImpl();
	} 
}

<bean id="factoryBean" class="com.itheima.factory.DynamicFactoryBean"/> 
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>

2.2 依赖注入

2.2.1 依赖注入是什么?

为了解耦,设置一种方法(比如set),在1接口实现类中使用2接口实现类定义的方法或数据。

  • 普通数据类型
  • 引用数据类型
  • 集合数据类型

依赖注入方式:
set方法
构造方法

2.2.2 set依赖注入

2.2.2.1 引用注入

在UserServiceImpl(1接口实现类)中添加UserDao(2接口实现类)方法

实现类的写法:
set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is .

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

xml配置文件的写法:

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"> 
	<property name="userDao" ref="userDao"/>
</bean>

2.2.2.2 普通数据类型注入

public class UserDaoImpl implements UserDao {
	private String company;
	private int age;
	public void setCompany(String company) {
		this.company = company;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void save() {
		System.out.println(company+"==="+age);
		System.out.println("UserDao save method running....");
	} 
}

xml文件配置

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 
	<property name="company" value="传智播客"></property> 	
	<property name="age" value="15"></property>
</bean>

2.2.2.3 List

public class UserDaoImpl implements UserDao {
	private List<String> strList;
	public void setStrList(List<String> strList) {
		this.strList = strList;
	}
	public void save() {
		System.out.println(strList);
		System.out.println("UserDao save method running....");
	} 
}

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 	
	<property name="strList"> 
		<list>
			<value>aaa</value> 
			<value>bbb</value> 
			<value>ccc</value>
		</list>
	</property>
</bean>

2.2.2.4 List

public class UserDaoImpl implements UserDao {
	private List<User> userList;
	public void setUserList(List<User> userList) {
		this.userList = userList;
	}
	public void save() {
		System.out.println(userList);
		System.out.println("UserDao save method running....");
	} 
}

<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 	
	<property name="userList"> 
		<list>
			<bean class="com.itheima.domain.User"/>
			<bean class="com.itheima.domain.User"/>
			<ref bean="u1"/>
			<ref bean="u2"/>
		</list>
	</property>
</bean>

2.2.2.5 Map

public class UserDaoImpl implements UserDao {
	private Map<String,User> userMap;
	public void setUserMap(Map<String, User> userMap) {
		this.userMap = userMap;
	}
	public void save() {
		System.out.println(userMap);
		System.out.println("UserDao save method running....");
	} 
}

<bean id="u1" class="com.itheima.domain.User"/>
<bean id="u2" class="com.itheima.domain.User"/>
<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 
	<property name="userMap"> 
		<map>
			<entry key="user1" value-ref="u1"/>
			<entry key="user2" value-ref="u2"/>
		</map>
	</property>
</bean>

2.2.2.6 Properties

public class UserDaoImpl implements UserDao {
	private Properties properties;
	public void setProperties(Properties properties) {
		this.properties = properties;
	}
	public void save() {
		System.out.println(properties);
		System.out.println("UserDao save method running....");
	} 
}

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"> 
	<property name="properties"> 
		<props> 
			<prop key="p1">aaa</prop> 
			<prop key="p2">bbb</prop> 
			<prop key="p3">ccc</prop>
		</props>
	</property>
</bean>

2.2.3 P命名空间注入(本质也是set)

引入P命名空间

xmlns:p="http://www.springframework.org/schema/p"

修改注入方式

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

2.2.4 构造方法引用注入

创建有参构造

public class UserServiceImpl implements UserService {
	@Override
	public void save() {
		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
		UserDao userDao = (UserDao) applicationContext.getBean("userDao");
		userDao.save();
	} 
}

xml文件配置

<bean id="userDao" class="com.itheima.dao.impl.UserDaoImpl"/>
<bean id="userService" class="com.itheima.service.impl.UserServiceImpl"> 	
	<constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

2.2.5 拆解配置文件,分模块开发(import)

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

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

3. 相关API

3.1 ApplicationContext的实现类

3.1.1 ClassPathXmlApplicationContext

它是从类的根路径下加载配置文件 推荐使用这种

3.1.2 FileSystemXmlApplicationContext

它是从磁盘路径上加载配置文件,配置文件可以在磁盘的任意位置。

3.1.3 AnnotationConfigApplicationContext

当使用注解配置容器对象时,需要使用此类来创建 spring 容器。它用来读取注解。

3.2 getBean()方法

4. 配置数据源

5. 注解开发

注解代替xml配置,文件可以简化配置,提高开发效率。

注解

说明

@Component

在类上用于实例化Bean

@Controller

在web层类上用于实例化Bean

@Service

在service层类上用于实例化Bean

@Repository

在dao层类上用于实例化Bean

@Autowired

在字段上用于根据类型依赖注入

@Qualifier

结合@Autowired一起使用用于根据名称进行依赖注入

@Resource

相当于@Autowired+@Qualifier,按照名称进行注入

@Value

注入普通属性

@Scope

标注Bean的作用范围

@PostConstruct

在方法上标注该方法是Bean的初始化方法

@PreDestroy

在方法上标注该方法是Bean的销毁方法

@Configuration

指定当前类是一个 Spring 配置类,当创建容器时会从该类上加载注解

@ComponentScan

用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的<context:component-scan base-package="com.itheima"/>一样

@Bean

使用在方法上,标注将该方法的返回值存储到 Spring 容器中

@PropertySource

用于加载.properties 文件中的配置

@Import

用于导入其他配置类

6. 整合Junit

6.1 原始Junit测试Spring的问题

在测试类中,每个测试方法都有以下两行代码:

ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
IAccountService as = ac.getBean("accountService",IAccountService.class);

6.2 Spring集成Junit

  • 让SpringJunit负责创建Spring容器,但是需要将配置文件的名称告诉它
  • 将需要进行测试Bean直接在测试类中进行注入

6.2.1 Spring集成Junit步骤

① 导入spring集成Junit的坐标
② 使用@Runwith注解替换原来的运行期
③ 使用@ContextConfiguration指定配置文件或配置类
④ 使用@Autowired注入需要测试的对象
⑤ 创建测试方法进行测试

① 导入spring集成Junit的坐标

<!--此处需要注意的是,spring5 及以上版本要求 junit 的版本必须是 4.12 及以上--> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-test</artifactId> <version>5.0.2.RELEASE</version>
</dependency> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope>
</dependency>

② 使用@Runwith注解替换原来的运行期

@RunWith(SpringJUnit4ClassRunner.class)
public class SpringJunitTest {
}

③ 使用@ContextConfiguration指定配置文件或配置类

@RunWith(SpringJUnit4ClassRunner.class)
//加载spring核心配置文件
//@ContextConfiguration(value = {"classpath:applicationContext.xml"})
//加载spring核心配置类
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
}

④ 使用@Autowired注入需要测试的对象

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
@Autowired
private UserService userService; }

⑤ 创建测试方法进行测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfiguration.class})
public class SpringJunitTest {
@Autowired
private UserService userService;
@Test
public void testUserService(){
userService.save();
} }


举报

相关推荐

0 条评论