0
点赞
收藏
分享

微信扫一扫

spring框架学习

Sikj_6590 2023-05-07 阅读 59
spring学习java实例化ListjQuery前端开发


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();
} }


举报

相关推荐

Spring 框架学习（九）---- Spring 整合 Mybatis 框架

mybatisspringjavasqlmysqlLinux系统/运维

Spring框架初学习

学习spring

Spring框架简单学习

springintellij-ideajavajava 7开发语言

Spring Cloud框架学习-Spring Cloud Gateway

spring cloud学习java

Spring框架的学习前言

学习java开发语言

Spring MVC框架学习笔记

tensorflowflaskpython图像处理

【Spring】Spring框架、SpringMVC学习参考资料

javaspringmvc

后端框架学习1-----Spring

javaspringxml配置文件

如何系统学习Spring框架

spring编程语言java设计模式java开发

Spring框架入门学习笔记

spring学习java
0 条评论