Spring 基础知识笔记【上】

最新推荐文章于 2022-04-07 15:42:32 发布
最新推荐文章于 2022-04-07 15:42:32 发布
阅读量283 收藏
点赞数
分类专栏： 笔记 Java 文章标签： java spring bean ioc
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44427114/article/details/109233831
版权
笔记 同时被 2 个专栏收录
34 篇文章 0 订阅
订阅专栏
Java
16 篇文章 0 订阅
订阅专栏

本篇博客内容

web Helloworld

TestDao.java

package dao;

public interface TestDao {
	public void sayHello();
}

TestDaoImpl.java

package dao;

public class TestDaoImpl implements TestDao{
	public void sayHello() {
		System.out.println("Hello asdasf");
	}
}

配置 applicationContext.xml

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	<bean id="testDao" class="dao.TestDaoImpl"></bean>

</beans>

创建servlet：HelloServlet.java
其中doGet函数：

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		ServletContext application = request.getServletContext();
		//WebApplicationContext context = (WebApplicationContext)application.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
		WebApplicationContext context = WebApplicationContextUtils.getRequiredWebApplicationContext(application);
		TestDao testDao = context.getBean("testDao",TestDao.class);
		testDao.sayHello();
	}

index.jsp

<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="ISO-8859-1">
<title>Insert title here</title>
</head>
<body>
	<a href="hello">hello fuck you</a>
</body>
</html>

普通helloworld用一个Junit Test

@Test
void test1() {
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    TestDao testDao = context.getBean("testDao",TestDao.class);
    testDao.sayHello();
}

依赖注入

依赖注入有两种方式，一种是构造方法注入，另一种是属性setter方法注入。

配置 spring-di.xml

<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

	<bean id="book" class="dao.Book">
		<property name="isbn" value="0001"></property>
		<property name="name" value="effective java"></property>
		<property name="price" value="80.6"></property>
	</bean>
	
	<bean id="book1" class="dao.Book">
		<constructor-arg value="0002" index="0"></constructor-arg>
		<constructor-arg value="56.3" index="2"></constructor-arg>
		<constructor-arg value="python" index="1"></constructor-arg>
	</bean>
</beans>

<property>标签为 setter 注入。
<constructor-arg>标签为 构造器注入

Junit Test：

void testDi() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-di.xml");
    Book book = (Book)context.getBean("book1");
    //Book book = (Book)context.getBean("book");
    System.out.println(book);
}

使用value子标签及<![CDATA[]]>处理特殊属性值。

如果value值里有特殊字符，如：
<property name="name" value="1+1<2"></property>
这时由于value="1+1<2"会出错，应该使用<![CDATA[]]>

spring-di.xml:

<bean id="book" class="dao.Book">
    <property name="isbn" value="0001"></property>
    <property name="name">
        <value><![CDATA[1+1<2?]]></value>
    </property>
    <property name="price" value="80.6"></property>
</bean>

Junit：

@Test
void testDi() {
    ApplicationContext context = new ClassPathXmlApplicationContext("spring-di.xml");
    Book book = (Book)context.getBean("book");
    System.out.println(book);
}

注入使用引用

<bean id="book" class="dao.Book">
    <property name="isbn" value="0001"></property>
    <property name="name">
        <value><![CDATA[1+1<2?]]></value>
    </property>
    <property name="price" value="80.6"></property>
    <property name="author" ref="author"></property>
</bean>

<bean id="book1" class="dao.Book">
    <constructor-arg value="0002" index="0"></constructor-arg>
    <constructor-arg value="56.3" index="2"></constructor-arg>
    <constructor-arg value="python" index="1"></constructor-arg>
    <constructor-arg ref="author" index="3"></constructor-arg>
</bean>

<bean id="author" class="dao.Author">
    <property name="name" value="Jinondo"></property>
    <property name="age" value="21"></property>
</bean>

注意里面不是 value=""，而是 ref=""

也可以直接用内部类

<bean id="book" class="dao.Book">
    <property name="isbn" value="0001"></property>
    <property name="name">
        <value><![CDATA[1+1<2?]]></value>
    </property>
    <property name="price" value="80.6"></property>
    <property name="author">
        <bean class="dao.Author">
            <property name="name" value="T0wn"></property>
            <property name="age" value="18"></property>
        </bean>
    </property>
</bean>

Bean的属性为集合类型:Array, List, Set, Map

<bean id="author" class="dao.Author">
    <property name="name" value="Jinondo"></property>
    <property name="age" value="21"></property>
    <property name="interest">
        <list>
            <value>Reading</value>
            <value>Dancing</value>
        </list>
    </property>
</bean>

或者是 map 等

<map>
    <entry key="" value=""></entry>
</map>

或 value 为引用

<map>
    <entry key="" value-ref=""></entry>
</map>

还有一种办法是定义在外面
首先要有util的引用资源

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/util
    http://www.springframework.org/schema/util/spring-util-4.0.xsd"
	>

<util:list id="interestList">
    <value>Singing</value>
    <value>exercise</value>
</util:list>

<bean id="author" class="dao.Author">
    <property name="name" value="Jinondo"></property>
    <property name="age" value="21"></property>
    <property name="interest" ref="interestList"></property>
</bean>

bean的实例化

在面向对象的程序中，想要使用某个对象，就需要先实例化这个对象。同样，在Spring中，要想使用容器中的Bean，也需要实例化Bean。实例化Bean有三种方式，分别为构造器实例化、静态工厂方式实例化和实例工厂方式实例化（其中最常用的是构造器实例化）。

提示：在前面的例子中都是使用构造器实例化

静态工厂方法实例化

静态工厂是实例化Bean的另一种方式。该方式要求自己创建一个静态工厂的方法来创建Bean的实例。

  1. 创建 MyBean.class。成员变量为name和age
  2. 创建 MyBean2Factory.class
public class MyBean2Factory {
	public static MyBean createBean(){
        return new MyBean("Jinondo",20);
    }

}
  1. 配置 spring-create.xml
<bean id="bean1" class="dao.MyBean2Factory" factory-method="createBean">
	<property name="name" value="wdnmd"></property>
</bean>
  1. 调用测试
@Test
void testCreate() {
	ApplicationContext context = new ClassPathXmlApplicationContext("spring-create.xml");
	MyBean bean1 = (MyBean)context.getBean("bean1",MyBean.class);
	System.out.println(bean1);
}

实例工厂方式实例化

实例工厂是采用直接创建Bean实例的方式，在配置文件中，通过factory-bean属性配置一个实例工厂，然后使用factory-method属性确定使用工厂中的哪个方法。

  1. 创建 MyBean.class。成员变量为name和age
  2. 创建 MyBean3Factory.class
public class MyBean3Factory {
	public MyBean createBean(){
        return new MyBean();
    }

}
  1. 配置 spring-create.xml
<bean id="beanFactory" class="dao.MyBean3Factory"></bean>
<bean id="bean2" factory-bean="beanFactory" factory-method="createBean">
	<property name="name" value="g-dragon"></property>
	<property name="age" value="33"></property>
</bean>

4.调用测试

@Test
void testCreate() {
	ApplicationContext context = new ClassPathXmlApplicationContext("spring-create.xml");
	MyBean bean2 = (MyBean)context.getBean("bean2",MyBean.class);
	System.out.println(bean2);
}

bean 的作用域

  1. 单例 singleton (为默认形式)

    singleton 是 Spring容器默认的作用域，当 Bean 的作用域为 singleton 时，Spring 容器就只会存在一个共享的 Bean实例。singleton 作用域对于无会话状态的Bean（如 Dao 组件、Service 组件）来说，是最理想的选择。

<bean id="student" class="dao.Student" scope="singleton"></bean>

测试

@Test
void testLifecycle() {
	ApplicationContext context = new ClassPathXmlApplicationContext("spring-lifecycle.xml");
	Student student1 = context.getBean("student",Student.class);
	Student student2 = context.getBean("student",Student.class);
	System.out.println(student1==student2);
}

结果为 true

  1. 原型 prototype

    对需要保持会话状态的 Bean（如Struts 2的 Action类）应该使用 prototype作用域。在使用 prototype作用域时，Spring容器会为每个对该 Bean的请求都创建一个新的实例。

<bean id="student" class="dao.Student" scope="prototype"></bean>

与上同一程序测试为 false

•singleton: 单例的(默认值)， 在整个IOC容器中只存在一个bean的对象。 而且在IOC容器对象被创建时，就创建单例的bean的对象。 后续每次通过getBean()方法获取bean对象时，返回的都是同一个对象。

•prototype: 原型的，在整个IOC容器中可有多个bean的对象。在IOC容器对象被创建时， 不会创建原型的bean的对象。而是等到每次通过getBean()方法获取bean对象时，才会创建一个新的bean对象返回。

bean 的生命周期

  1. singleton作用域
    Spring容器可以管理singleton作用域的Bean的生命周期，在此作用域下，Spring能够精确的知道该Bean何时被创建，何时初始化完成，以及何时被销毁。

  2. prototype作用域
    prototype作用域的Bean，Spring只负责创建，当容器创建了Bean实例后，Bean的实例就交给客户端代码来管理，Spring容器将不再跟踪其生命周期。

<bean id="student" class="dao.Student" scope="singleton" init-method="init" destroy-method="destroy">
	<property name="name" value="cyt"></property>
	<property name="age" value="21"></property>
</bean>

Student.java

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

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

基于 xml 的自动装配

自动装配只针对于引用型属性，即手动装配的 ref=""

  1. 根据类型自动装配：将类型匹配的bean作为属性注入到另一个bean中。若IOC容器中有多个与目标bean类型一致的bean，Spring将无法判定哪个bean最合适该属性，所以不能执行自动装配

设有People.java 和 Address.java，People和Address为依赖关系
People有三个属性

private String id;
private String name;
private Address address;

<bean id="people" class="dao.People" autowire="byType">
	<property name="id" value="0001"></property>
	<property name="name" value="jinondo"></property>
</bean>

<bean id="address" class="dao.Address">
	<property name="province" value="GuangDong"></property>
	<property name="city" value="DG"></property>
</bean>

如果出现多个 class=“dao.Address” 的bean，byType的方式则会出错

  1. 根据名称自动装配：必须将目标bean的名称和属性名设置的完全相同。
<bean id="people" class="dao.People" autowire="byName">
	<property name="id" value="0001"></property>
	<property name="name" value="jinondo"></property>
</bean>

<bean id="address" class="dao.Address">
	<property name="province" value="GuangDong"></property>
	<property name="city" value="DG"></property>
</bean>

<bean id="address2" class="dao.Address">
	<property name="province" value="GuangDong"></property>
	<property name="city" value="ShanTou"></property>
</bean>

基于注解(Annotation)的装配

Repository，Controller，Service：

@Repository("userDaoImpl")
public class UserDaoImpl implements UserDao {

	@Override
	public void addUser() {
		System.out.println("Dao: addUser");

	}
}

@Controller
public class UserController {
	public void handleUserInput() {
		System.out.println("Controller: handle User Input");
	}
}

@Service
public class UserService {
	public void addUser() {
		System.out.println("Service: add User");
	}
}

xml 中的配置

<context:component-scan base-package="cyt"></context:component-scan>

bean id 默认为类名首字母小写，注解可以设置 bean 的 id，如@Repository("userDaoImpl")

包含与排除

排除
<context:component-scan base-package="cyt">
	<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
</context:component-scan>
包含：只扫描选中的 bean！

注意排除应该配合父标签，即scan标签中的 use-default-filters 属性进行使用，即设置 use-default-filters="false"

<context:component-scan base-package="cyt" use-default-filters="false">
	<context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
</context:component-scan>

@Autowire工作机制

引用在基于注解装配时需要在引用前加上 @Autowire 注解

  1. Controller 中有 Service 的引用
@Repository("userDaoImpl")
@Controller
public class UserController {
	
	@Autowired
	private UserService service;
	
	public void handleUserInput() {
		System.out.println("Controller: handle User Input");
		service.addUser();
	}
}
  1. Service 里有 Dao 的引用
@Service
public class UserService {
	
	@Autowired
	private UserDao dao;
	
	public void addUser() {
		System.out.println("Service: add User");
		dao.addUser();
	}
}

Junit Test 测试

@Test
void test2() {
	context = new ClassPathXmlApplicationContext("applicationContext.xml");
	UserController userController = context.getBean("userController",UserController.class);
	userController.handleUserInput();
}

由以上例子说明：@Autowired 注解对引用的装配属于 ByType 类型
如果 ByType 类型不能唯一找出一个，就会在 ByType 类型找出的多个bean基础上，进一步根据名字去找，例如 在@Repository(“userDaoImpl”) 时设置的 userDaoImpl。
如果不能按名字区别开2个或多个bean，则会出错！

@Qualifiter

@Qualifiter可以辅助@Autowire确定需要装配的Bean的id，在@Autowired找到多于两个的bean时，也可以用 @Qualifiter 直接设置要装配的 bean 的 id。

@Service
public class UserService {
	
	@Autowired
	@Qualifier("userDaoImpl")
	private UserDao dao;
	
	public void addUser() {
		System.out.println("Service: add User");
		dao.addUser();
	}
}
这个饕字怎么读
关注
专栏目录
Spring全家桶知识笔记.pdf
10-29
Spring的IoC容器在这些基础上提供了更多高级服务，比如bean的实例缓存、生命周期管理、代理、事件发布和资源加载等。 Spring的高层容器视图展示了容器启动时如何读取应用提供的配置信息，生成bean配置注册表，然后...
Spring5笔记与代码.zip
09-25
《Spring5笔记与代码》是针对Spring框架第五个主要版本的学习资源，包含了理论知识和实践代码，旨在帮助用户深入理解并掌握Spring5的核心概念和技术。本文将详细解析这些知识点，并结合提供的文件进行深入探讨。 ...
Spring学习笔记之bean的基础知识
08-28
Spring框架中的Bean是其核心概念，它代表了应用程序中的对象，这些对象由Spring的Inversion of Control (IoC) 容器负责管理和初始化。在Spring和SpringMVC中，Bean的使用无处不在，理解并熟练掌握Bean的概念对于...
spring课堂笔记的相关知识
09-17
Spring就是一个大工厂，可以将所有对象创建和依赖关系维护，交给Spring管理 AOP编程的支持 Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能 声明式事务的支持 只需要通过配置就可以...
spring boot基础笔记
10-31
Spring Boot基础笔记知识点...这些知识点涵盖了Spring Boot的基础知识，适合初学者了解和学习。通过上述笔记内容，可以帮助初学者快速理解Spring Boot的核心概念和基本用法，并学会如何构建一个简单的Spring Boot项目。
SaToken登录鉴权示例的源码跟踪
Jinondo's Blog
04-01 4747
源码跟踪 这里使用官方的springboot-demo来测试跟踪 源码跟踪 - 登录 登录分为存有session时的登录和没有session时的登录 没有session时的登录： StpLogic： /** * 会话登录，并指定所有登录参数Model * @param id 登录id，建议的类型：（long | int | String） * @param loginModel 此次登录的参数Model */ public void login(Object id, SaLogin
Spring Cloud Stream RabbitMQ动态路由Key
Jinondo's Blog
04-07 4538
Spring Cloud Stream RabbitMQ动态路由Key 前言 这里有个业务是这样的，我需要在不同的操作后给用户发送不同的邮件，由于比较耗时所以引入消息中间件，不同的邮件对应的消息类型是不一样的，所以需要生产者往队列里发送数据时绑定好路由key，例如： 图里表示交换机根据路由key绑定了不同的队列。 要达到这种效果，首先消费者肯定是可以根据路由key来决定消息是不是发送给自己的，对于生产者则需要用到routingKeyExpression 来决定往哪个路由key发送数据（大概是这个意思）。
No serializer found for class org.apache.ibatis.executor.loader.javassist.JavassistProxyFactory...
Jinondo's Blog
12-02 3096
问题描述 mybatis配置懒加载导致RestController或responsebody返回对象Jackson解析失败。 关键信息： No serializer found for class org.apache.ibatis.executor.loader.javassist.JavassistProxyFactory$EnhancedResultObjectProxyImpl and no properties discovered to create BeanSerializer com.fas
Knife4j文档请求异常
Jinondo's Blog
02-26 2011
这里先贴一下官方的文档 https://doc.xiaominfo.com/knife4j/faq/knife4j-exception.html 当然了，这些对我没什么用，我的错是很奇怪，正常访问接口是没问题的，但是访问swagger文档和knife4j访问不通。 原因： 因为我的swagger文档是在另外一个模块下的，而我新建的一个服务是在另外的模块下，依赖引入是没有问题，问题出在容器扫描包的时候没有扫描到swagger的资源，原来是我没有加 @ComponentScan 注解 mapperscan是有
SpringDataJpa 使用save创建表出错：java.sql.SQLSyntaxErrorException: Table doesn‘t exist
Jinondo's Blog
02-03 808
问题描述 在使用 SpringDataJpa 时遇到一个错误 在Jpa配置中配置了 hibernate.hbm2ddl.auto <property name="jpaProperties"> <props> <prop key="hibernate.hbm2ddl.auto">create</prop> </props> </property> 测试使用如下： @Test @Transaction
Java8 jdk1.8新特性
Jinondo's Blog
11-18 448
Record some significant JDK1.8 operations Lambda anonymous inner class // Original solution Comparator<Integer> comparator1 = new Comparator<Integer>() { @Override public int compare(Integer o1, Integer o2) { return Integer.co.
MyBatis基础知识笔记【下】
Jinondo's Blog
10-23 312
本篇博客内容： MyBatis 实现 “一对多” 查询 MyBatis 实现 “多对多” 查询 MyBatis 实现动态SQL 8 一对多查询 “一对多”对于“多对一”的那方其实操作和一对一完全一致，参照上两节，这里只举例一对多 8.1 一对多关联查询 8.1.1 类的设计 public class User { private Integer userId; private String name; private Integer gender; private IdCard idCar
Java并发与Java内存模型 --《Java并发编程的艺术》
Jinondo's Blog
11-18 288
Java 并发机制的底层实现原理 Volatile 的应用 定义：Java变成语言允许线程访问共享变量，为了确保共享变量能被准确和一致地更新，线程应该确保通过排它锁单独获得这个变量。 几个术语： 缓存行（cache line）是CPU缓存中可分配、操作的最小存储单元，就是获取一块内存数据，放入缓存，这块数据成为缓存行。 缓存行填充：当处理器识别到从内存中读取操作数是可缓存的，处理器读取整个高速缓存行到适当的缓存（L1,L2,L3的或所有） 缓存命中“如果进行高速缓存行填充操作的内存位置仍然是
ssm基础知识笔记 (Spring + Spring MVC + MyBatis)
Jinondo's Blog
10-23 211
这是本人学习 Spring + Spring MVC + MyBatis 所做的笔记，方便自己在以后需要时查阅翻看，对于正在学ssm基础的或者已经学过的各位希望可以提供帮助，共同学习。 Spring 基础知识笔记【上】 主要内容： 依赖注入 bean的实例化 bean的作用域 bean的生命周期 Spring 基于xml的自动装配 Spring 基于注解（Annotation）的装配 Spring 基础知识笔记【下】 主要内容： Spring AOP JDBC Template Spring 声明式
MyBatis基础知识笔记【上】
Jinondo's Blog
10-23 195
本篇博客内容： 初始配置流程 基于Mapper接口开发 MyBatis全局配置文件 CRUD 增删改查操作 1 初始配置流程 实际开发不应用此方法 1.1 导入相关包 方便打印相关信息，加入 log4j.xml 配置文件至 classpath 下 <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd"> <log4j:configuration
SSM 整合笔记
Jinondo's Blog
01-20 172
SSM整合 环境配置 要手动导的包很多，还是maven好啊… db.properties jdbc.driver=com.mysql.cj.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/ssm?serverTimezone=Hongkong jdbc.username=root jdbc.password=cyt19880818 web.xml 配置 <?xml version="1.0" encoding="UTF-8"?> <we
SpringMVC 笔记【下】
Jinondo's Blog
01-20 155
二、SpringMVC常用技术 本节示例项目的准备与第一节大致一致： 导包： 添加全局配置文件： 其中依赖包括：bean context mvc <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="
MyBatis基础知识笔记【中】
Jinondo's Blog
10-23 143
本篇博客内容： SQL语句的参数传递 一对一关联查询 一对一分步查询 5 SQL语句的参数传递 5.1 单个普通(基本/包装+String)参数 这种情况 MyBatis 可直接使用这个参数，不需要经过任何处理。 取值：#{随便写} 例如我们add的代码中直接用 #{id} 5.2 POJO（bean对象） 当这些参数属于我们业务POJO时，我们直接传递POJO 取值: #{POJO的属性名} 例如delete，search其他例子 5.3 多个参数 5.3.1 Mybatis自动包装成 ma
Spring框架基础知识笔记：IOC、依赖注入与Bean管理
"Spring 框架笔记" Spring 框架是 Java 企业级应用程序的核心框架之一，由 Rod Johnson 创造。Spring 框架的主要功能是提供了一种轻量级的、非入侵式的框架来实现企业级应用程序的开发。 **IOC(Inverse of ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值