spring入门

已于 2022-08-23 14:00:50 修改
阅读量437 收藏
点赞数
文章标签： spring java mybatis
于 2022-08-22 02:43:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67376124/article/details/126442985
版权

目录

Spring的基本概念

🚩spring是什么？

🚩spring项目的出发点：

🚩spring的控制反转(依赖注入)

AOP是什么 ？ 

示例：

🏳‍🌈创建web工程

🏳‍🌈配置pom文件

🏳‍🌈创建spring的配置文件

🏳‍🌈示例

①示例一(普通)

②示例二(sbstract和parent的使用) 

③示例三(有参构造创建javaBean)

④实例四(init-method的使用)

⑤示例五(复杂属性-引入属性的使用ref)

⑥示例六(集合、数组的使用) 

⑦多配置文件的处理

Spring的基本概念

🚩spring是什么？

spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

🚩spring项目的出发点：

  • 目的：提供一种贯穿始终的解决方面，将各种专用框架整合成一个连贯的整体框架，简化企业级应用的开发（有点像粘合剂）
  • 鼓励最佳实践： 例如spring将“针对接口编程”的成本降到了最小
  • 非侵入性： 应用对象尽量避免依赖框架，IoC和AOP是避免依赖的关键技术
  • 统一配置： 好的框架应该让应用配置灵活且统一
  • 易于测试： 使单元测试尽可能简单
  • 可扩展：

简单来说，spring就是一个轻量级的控制(IOC)和面向切面编程(AOP)的容器框架。

🚩spring的控制反转(依赖注入)

控制反转IOC(inversion of control)，控制反转其实就是控制权的反转，我们都知道传统的，由代码直接操控的，那么反转了之后就是将控制权直接给到了外部的容器。这就是反转的概念 。控制反转又被称为依赖注入DI(Dependency Injection) ，意思就是由容器动态的将某种关系注入到组件中去。 

AOP是什么 ？ 

  • 连接点(Joinpoint)：程序执行过程中明确的点，如方法的调用，或者异常的抛出.
  • 目标(Target)：被通知(被代理)的对象
  • 通知(Advice)：在某个特定的连接点上执行的动作，同时Advice也是程序代码的具体实现，例如一个实现日志记录的代码(通知有些书上也称为处理)
  • 代理(Proxy)：将通知应用到目标对象后创建的对象(代理=目标+通知),请注意：只有代理对象才有AOP功能，而AOP的代码是写在通知的方法里面的
  • 切入点(Pointcut)：多个连接点的集合，定义了通知应该应用到那些连接点。(也将Pointcut理解成一个条件 ，此条件决定了容器在什么情况下将通知和目标组合成代理返回给外部程序)
  • 适配器(Advisor)：适配器=通知(Advice)+切入点(Pointcut) 

示例：

🏳‍🌈创建web工程

这里我们直接创建一个web项目，并转换为web3.1，具体步骤见maven的安装和使用_一麟yl的博客-CSDN博客

🏳‍🌈配置pom文件

下面是我们需要的依赖配置。

注意：个人建议需要什么用到什么模块就使用什么模块的依赖。

<properties>
		<hibernate.version>5.2.12.Final</hibernate.version>
		<mysql.driver.version>5.1.44</mysql.driver.version>
		<spring.version>5.2.6.RELEASE</spring.version>
		<struts2.version>2.5.13</struts2.version>
		<slf4j.version>1.7.7</slf4j.version>
		<log4j.version>2.9.1</log4j.version>
		<disruptor.version>3.2.0</disruptor.version>
		<junit.version>4.12</junit.version>
		<servlet.version>4.0.1</servlet.version>
		<jstl.version>1.2</jstl.version>
		<standard.version>1.1.2</standard.version>
		<tomcat-jsp-api.version>8.5.20</tomcat-jsp-api.version>
	</properties>

	<dependencies>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<!-- spring 相关 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-web</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aop</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-aspects</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-beans</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- 数据库驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>${mysql.driver.version}</version>
		</dependency>
	
		<!--4. log配置：Log4j2 + Slf4j -->
		<!-- slf4j核心包 -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${slf4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${slf4j.version}</version>
			<scope>runtime</scope>
		</dependency>

		<!--用于与slf4j保持桥接 -->
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-slf4j-impl</artifactId>
			<version>${log4j.version}</version>
			<exclusions>
				<exclusion>
					<artifactId>slf4j-api</artifactId>
					<groupId>org.slf4j</groupId>
				</exclusion>
			</exclusions>
		</dependency>

		<!--核心log4j2jar包 -->
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-api</artifactId>
			<version>${log4j.version}</version>
		</dependency>
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-core</artifactId>
			<version>${log4j.version}</version>
		</dependency>

		<!--web工程需要包含log4j-web，非web工程不需要 -->
		<dependency>
			<groupId>org.apache.logging.log4j</groupId>
			<artifactId>log4j-web</artifactId>
			<version>${log4j.version}</version>
			<scope>runtime</scope>
		</dependency>
		<!--需要使用log4j2的AsyncLogger需要包含disruptor -->
		<dependency>
			<groupId>com.lmax</groupId>
			<artifactId>disruptor</artifactId>
			<version>${disruptor.version}</version>
		</dependency>

		<!--5. other -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>javax.servlet-api</artifactId>
			<version>${servlet.version}</version>
			<scope>provided</scope>
		</dependency>

		<!--6. jstl -->
		<dependency>
			<groupId>javax.servlet.jsp.jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>
		<dependency>
			<groupId>taglibs</groupId>
			<artifactId>standard</artifactId>
			<version>${standard.version}</version>
		</dependency>

		<!-- 7. jsp自定义标签依赖 (必须与tomcat的版本一致) -->
		<dependency>
			<groupId>org.apache.tomcat</groupId>
			<artifactId>tomcat-jsp-api</artifactId>
			<version>${tomcat-jsp-api.version}</version>
			<scope>provided</scope>
		</dependency>

	</dependencies>

注： 该依赖配置不仅包含了spring，同时也包含了hibernate，struts，mysql驱动等。

🏳‍🌈创建spring的配置文件

spring.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" xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">


	
</beans>

进行到这里我们的容器就算搭建好了，我们来两个实例。

🏳‍🌈示例

①示例一(普通)

🟠这里我们创建一个学生实体类(Student.java)

package com.ljq.spring01.model;

/**
 * 学生实体
 * @author 一麟
 *
 */
public class Student  {
	
	private String name;

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}
	
}

🟢并在spring.xml文件中配置好

<bean id="demo" class="com.ljq.spring01.model.Student">
		<property name="name">
			<value>一麟</value>
		</property>
	</bean>

配置文件说明：

ID:在容器中确保了bean的唯一(不能以/开头)

class:bean的权限类名

name：在容器中标记bean的名字(唯一，不能以/开头，能够存在多个值，用逗号隔开)

scope:(singleton|prototype)默认是singleton
singleton: 单例模式, 在每个Spring IoC容器中一个bean定义对应一个对象实例
prototype： 原型模式/多例模式, 一个bean定义对应多个对象实例

parent：指定一个父bean(必须要有继承关系才行)

abstract: 将一个bean定义成抽象bean(抽象bean是不能实例化的),抽象类一定要定义成抽象bean,非抽象类也可以定义成抽象bean

🟤main方法测试

package com.ljq.spring01.test;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.ljq.spring01.model.Student;

/**
 * 测试
 * 
 * @author 一麟
 *
 */
public class Test {

	public static void main(String[] args) {
		// 获取spring.xml文件的上下文
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
		// 用上下文获得ID为student的bean
		Student stu = (Student) ctx.getBean("student");
		System.out.println(stu);
	}

}

运行结果：

②示例二(sbstract和parent的使用) 

这里我们给student实体类安排一个父类(person):

package com.ljq.spring01.model;

/**
 * 人物实体类
 * 
 * @author 一麟
 *
 */
public abstract class Person {

	private Integer age;

	public Integer getAge() {
		return age;
	}

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

}

并让student实体类继承这个类：

package com.ljq.spring01.model;

/**
 * 学生实体
 * 
 * @author 一麟
 *
 */
public class Student extends Person {

	private String name;

	public String getName() {
		return name;
	}

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

	@Override
	public String toString() {
		return "Student [name=" + name + "]";
	}

}

然后就是配合spring.xml文件：

<!-- parent填的是父类bean的ID -->
	<bean id="student" class="com.ljq.spring01.model.Student" parent="person">
		<property name="name">
			<value>一麟</value>
		</property>
	</bean>

	<!-- ps:这个地方的abstract一定要填,而且要填true,因为person类是一个抽象类,abstract默认是false -->
	<bean id="person" class="com.ljq.spring01.model.Person" abstract="true">
		<property name="age">
			<value>18</value>
		</property>
	</bean>

继续运行我们上面的test类的main方法：

public static void main(String[] args) {
		// 获取spring.xml文件的上下文
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
		// 用上下文获得ID为student的bean
		Student stu = (Student) ctx.getBean("student");
		System.out.println("学生名字:"+stu.getName());
		System.out.println("学生年龄:"+stu.getAge());
	}

运行结果：

③示例三(有参构造创建javaBean)

注意：这种方式我们一定在实体类中写好有参构造

这里我们在student类中加入有参构造： 

public Student(String name) {
		super();
		this.name = name;
	}

这种方式跟第二种方式是差不多的，只需要将bean中的property改为constructor即可，配置文件如下：

<bean id="student" class="com.ljq.spring01.model.Student" parent="person">
		<!-- <property name="name">
				<value>一麟</value>
			</property> -->
		<constructor-arg index="0">
			<value>一麟</value>
		</constructor-arg>
	</bean>

这种构造方法是根据属性的下标来植入值的，我们也可以直接设置属性名字如：

<bean id="student" class="com.ljq.spring01.model.Student" parent="person">
		<!-- <property name="name">
				<value>一麟</value>
			 </property> -->
		<!-- 
			<constructor-arg index="0">
				<value>一麟</value>
			</constructor-arg>
		 -->
		 <constructor-arg name="name">
				<value>一麟</value>
		 </constructor-arg>
	</bean>

运行之前的main方法，运行结果如下：

④实例四(init-method的使用)

这种方式其实也很简单，就是在实体类中写一个初始化的方法，然后在容器中的bean直接配置即可。

首先，我们在student类中加入init方法：

    /**
	 * 初始化方法,表示正常启动
	 */
	public void init() {
		System.out.println("我是"+this.name+"大帅哥");
	}

然后配置spring.xml文件：

<bean id="student" class="com.ljq.spring01.model.Student" parent="person" init-method="init">
		<!-- <property name="name">
				<value>一麟</value>
			 </property> -->
		<!-- 
			<constructor-arg index="0">
				<value>一麟</value>
			</constructor-arg>
		 -->
		 <constructor-arg name="name">
				<value>一麟</value>
		 </constructor-arg>
	</bean>

最后还是使用之前的main方法测试，结果如下：

⑤示例五(复杂属性-引入属性的使用ref)

这里我们先创建一个地址实体类方便测试address.java:

package com.ljq.spring01.model;

/**
 * 地址实体类
 * 
 * @author 一麟
 *
 */
public class Address {

	private String city;// 城市

	private String street;// 街道

	public String getCity() {
		return city;
	}

	public void setCity(String city) {
		this.city = city;
	}

	public String getStreet() {
		return street;
	}

	public void setStreet(String street) {
		this.street = street;
	}

	@Override
	public String toString() {
		return "Address [city=" + city + ", street=" + street + "]";
	}

}

并在student中加入address属性： 

    private Address address;//地址

	public Address getAddress() {
		return address;
	}

	public void setAddress(Address address) {
		this.address = address;
	}

spring.xml配置：

<!-- parent填的是父类bean的ID -->
	<bean id="student" class="com.ljq.spring01.model.Student"
		parent="person" init-method="init">
		<property name="name">
			<value>一麟</value>
		</property>
		<!-- <constructor-arg index="0"> <value>一麟</value> </constructor-arg> -->
		<!-- <constructor-arg name="name"> <value>一麟</value> </constructor-arg> -->
		<property name="address" ref="address" />
	</bean>

	<!-- ps:这个地方的abstract一定要填,而且要填true,因为person类是一个抽象类,abstract默认是false -->
	<bean id="person" class="com.ljq.spring01.model.Person"
		abstract="true">
		<property name="age">
			<value>18</value>
		</property>
	</bean>

	<bean id="address" class="com.ljq.spring01.model.Address">
		<property name="city">
			<value>长沙</value>
		</property>
		<property name="street">
			<value>天顶街道</value>
		</property>
	</bean>

main方法：

public static void main(String[] args) {
		// 获取spring.xml文件的上下文
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
		// 用上下文获得ID为student的bean
		Student stu = (Student) ctx.getBean("student");
		System.out.println("学生名字:" + stu.getName());
		System.out.println("学生年龄:" + stu.getAge());
		System.out.println("学生地址:" + stu.getAddress());
	}

运行结果：

⑥示例六(集合、数组的使用) 

不仅如此，spring容器还能够注入集合、数组。

直接在student类中声明属性：

private int[] arr;
	private List list;
	private Map map;
	private Properties prop;
	
	public Properties getProp() {
		return prop;
	}

	public void setProp(Properties prop) {
		this.prop = prop;
	}

	public int[] getArr() {
		return arr;
	}

	public void setArr(int[] arr) {
		this.arr = arr;
	}

	public List getList() {
		return list;
	}

	public void setList(List list) {
		this.list = list;
	}

	public Map getMap() {
		return map;
	}

	public void setMap(Map map) {
		this.map = map;
	}

修spring.xml配置文件：

<bean id="student" class="com.ljq.spring01.model.Student"
		parent="person">
		<!-- init-method="init" -->
		<!-- <property name="name"> <value>一麟</value> </property> -->
		<!-- <constructor-arg index="0"> <value>一麟</value> </constructor-arg> -->
		<!-- <constructor-arg name="name"> <value>一麟</value> </constructor-arg> -->
		<!-- <property name="address" ref="address" /> -->
		<property name="list">
			<list>
				<value>湖南</value>
				<value>湖北</value>
				<value>意大利</value>
			</list>
		</property>
		<property name="arr">
			<array>
				<value>1</value>
				<value>2</value>
				<value>3</value>
			</array>
		</property>
		<property name="map">
			<map>
				<entry key="A" value="a" />
				<entry key="B" value="b" />
				<entry key="C" value="c" />
			</map>
		</property>
		<property name="prop">
			<props>
				<prop key="中国">Chain</prop>
				<prop key="意大利">Italy</prop>
				<prop key="美国">US</prop>
			</props>
		</property>
	</bean>

main方法:

public static void main(String[] args) {
		// 获取spring.xml文件的上下文
		ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
		// 用上下文获得ID为student的bean
		Student stu = (Student) ctx.getBean("student");
//		System.out.println("学生名字:" + stu.getName());
//		System.out.println("学生年龄:" + stu.getAge());
//		System.out.println("学生地址:" + stu.getAddress());
		System.out.println(Arrays.toString(stu.getArr()));
		System.out.println(stu.getList());
		System.out.println(stu.getMap());
		System.out.println(stu.getProp());
	}

运行结果：

⑦多配置文件的处理

当我们的工程存在多个模块需要配置多个配置文件的时候，一个一个获取上下文实属是不方便。

这个时候我们可以将各个模块全部集成到一个配置文件里面。

首先，我们将之前的spring.xml文件改为spring-a.xml假设这个文件负责a模块，然后重新创建一个新的spring.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"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">

	<!-- 引入a模块的配置文件 -->
	<import resource="spring-a.xml" />

</beans>

我们每次新增一个模块配置文件的时候只需要将其配置在总配置文件中即可，这个时候就能够解决多模块配置文件的问题了。

🏳‍🌈简化bean的获取

在我们之前的代码里面我们是这样获取bean对象的：

        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("spring.xml");
		
		Student stu = (Student) ctx.getBean("student");

这样写是存在问题的而且也不是方便，每次需要配置文件上下文的时候都需要new 一个

ClassPathXmlApplicationContext，使得我们的工程的性能损耗，这样会导致什么问题呢？

有没有想过如果我们的线程配合也在这个配置文件中，那么这个线程就会被启动两次，一次是web容器初始化启动的时候，另一次就是这个地方，被new的时候会被启动一次，就相当于被重新初始化了，这就是明显的冗余。

那我们要这么解决这个问题呢？

这个时候我们就选择不直接new ClassPathXmlApplicationContext，而是新建一个工具类实现ApplicationContextAware接口，实现之后就大大方便了我们获取ApplicationContext中的所有Bean，接下来我们来看看这个接口具体是使用。

ApplicationContextAware的使用：

package com.ljq.spring01.util;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * 简化获取bean
 * 
 * @author 一麟
 *
 */
@Component
public class SpringBeanUtil implements ApplicationContextAware {

	private static ApplicationContext applicationContext;

	/**
	 * spring通过注入的方式自动调用该方法将上下文设置好
	 */
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		this.applicationContext = applicationContext;
	}

	/**
	 * 根据bean的ID获取bean
	 * 
	 * @param <T>
	 * @param id
	 * @return
	 */
	public static <T> T getBean(String id) {
		Object object = null;
		object = applicationContext.getBean(id);
		return (T) object;
	}

}

在这个类中我们通过实现ApplicationContextAware这个感知接口实现重写setApplicationContext方法，这个方法会被spring自动注入上下文，只需要在配置文件中加入

<!-- 配置获取bean的工具类 -->
	<bean id="springBeanUtil"
		class="com.ljq.spring01.util.SpringBeanUtil"></bean>

或者在工具类中也需要加入注册注解：

@Component

这样我们的工具类就搞定了。

下面是关于工具类的调用：main方法测试 ：

        new ClassPathXmlApplicationContext("spring.xml");
    	Student stu = (Student) SpringBeanUtil.getBean("student");
		System.out.println(Arrays.toString(stu.getArr()));
		System.out.println(stu.getList());
		System.out.println(stu.getMap());
		System.out.println(stu.getProp());

一麟yl
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Spring 基础实例1
maxcode
01-05 346
applicationContext.xml Action： @Controller public class
基于springboot的医院信息管理系统
znzbs的博客
06-08 1247
该项目是用springboot+layui+shiro写的医院管理系统，该系统的业务比较复杂，数据库一共有36张表。 项目分为门诊管理、住院管理、系统管理、统计管理、数据中心、排班管理、仓库管理、药房管理 本系统重点是门诊和住院管理 填写患者的详细信息，如姓名，年龄、手机号、性别、身份证号、选择科室挂号类型医生、会出来相对的挂号费，点击提交的时候会判断你输入的各项信息是否正确，如果该手机号或者该身份证号正在就诊，则会提示该手机号或者该身份证号正在就诊。挂号页面会根据单选按钮来查询全部的挂号，当天的挂号
Spring框架(七)：使用纯注解方式实现IOC案例
yu1755128147的博客
12-16 229
一、新注解的说明 1、@Configuration 作用：指定当前类是一个配置类，作用和bean.xml是一样的。 注意：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。 2、@ComponentScan 作用：用于通过注解指定spring在创建容器时要扫描的包； 属性：value用于指定创建容器时要扫描的包（baseP...
Spring基本概念和创建流程
Zincy星辰
07-18 620
SpringFramework）是一个开源框架。其支持广泛的应用场景，可以让Java企业级的应用程序开发起来更简单。IoC容器（InversionofControl）控制反转容器【IoC】实现代码解耦；类的创建顺序与传统相比发生了反转；调用下属类的控制权发生反转【DI】DependencyInjection依赖注入。由IoC容器在运行期间，动态地将某种依赖关系注入到对象中SpringIoC容器的基本功能：存【将对象存储在Spring容器中】取【将对象从Spring容器中取出来】......
Spring的创建与使用
最新发布
qq_59063493的博客
04-24 152
Spring的初始创建和使用
Spring入门
08-02
Spring入门，关于Spring的详细解释以及spring的工作原理！
Spring入门例子
04-14
Spring入门例子，只是实现了如何注入依赖，具体细节可以查看博客https://blog.csdn.net/qq_29924227/article/details/79942724
Spring入门经典
05-08
Beginning.Spring-Spring入门经典.pdf 学习 Spring 很好的入门书
2021-04-09——Spring框架-——2
weixin_53371536的博客
04-09 188
Spring框架 Spring DI（依赖注入）的实现方式：属性注入和构造注入 依赖注入（Dependency Injection，DI）和控制反转含义相同，它们是从两个角度描述的同一个概念。 当某个Java实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例（例如，使用 new 关键字获得被调用者实例），而使用Spring框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创建，这称为控制反转。 Spring 容器在创建被调...
spring实现属性值的注入
weixin_43723296的博客
07-01 550
首先创建一个实体类User 以User类为例，展示对实体类中基本数据类型属性进行初始化 这里有两个点需要注意：1、初始化对象时，使用property标签，实际在初始化时，会调用类中对应属性的set方法；2、日期类默认使用格式为：yyyy/MM/dd，如果要使用其他类型则需要自定义数据类型转换器： 然后在配置文件中托管自定义的数据类型转换器 最后将自定义的数据类型转换器交由数据类型转换器工厂对象进行管理 再创建Aoo实体类演示String、List、Set、Map、Properties类型
spring的创建和使用
weixin_44431128的博客
04-08 96
虽然简洁，但如果spring中一个类型存储了多个实例，那么使用类型获取bean就会报错。：一次性加载并初始化所有的bean对象。特征：节省内存，但调用时才加载初始化，bean到spring中，性能不高。：lazy load，需要哪个才去加载。这里的存储是声明式的，真正的存储在第三大步的第1或第2步。特征：比较费内存，但是一次性加载后，之后的读取会非常的快。spring中一个类型存储的多个实例，是不相同的。出现这两部分，说明maven项目初始化好了。来作为 Spring 的上下文。之外，我们还可以使用。
Spring学习:手写简单实现Spring的IOC功能(简单实现依赖注入以及单例多例注解)
bilibilidicks的博客
06-28 374
选择quickstart进行创建即可，除了测试类无需引入其他jar包坐标只需引入junit即可 ，方便后续测试容器构造器部分代码，为了实现方便，未对扫描包的字节码文件做递归扫描，只扫描一层，后续可改为递归扫描包内字节码文件。Spring的IOC容器有一个重要方法：getBean方法，此方法利用的beanDefinition对象在IOC初始化过程中进行构建，方便getBean调用，减少其代码量。扫包过程中获取到的单例池对象在创建完毕后再逐一放入singletonObjMap中。 BeanDefinit
Spring的IOC的注解开发（案例+解析）
程序员猫爪
07-06 1198
Spring 开发的时候可以配置XML也可以用注解开发， 一般情况下使用XML的较多，但是XML也有缺点， 注解开发的优点就是方便，无论是将类交给Spring管理还是属性注入都直接在，当前类上或者方法上，或者属性上，添加注解即可， XML的优点是逻辑清晰 两种方式各有优缺点， 在不同情况下选择不同的开发方式， 下面将介绍Spring的注解开 Spring的IOC的注解开发：普通属性 Spring的IOC的注解开发：注解详解+属性注入 Bean的其他的注解 IOC的XML和注解开发比较 XML和注解开发的整合
Spring基于注解开发案例
you4580的专栏
11-02 223
如上图，重新在config包下面写一个配置类JDBCConfig，如果把这个配置类的注解@Configuration省略不写，就要把这个配置类JDBCConfig.class加到容器对象的参数中。下面我们需要对注解改造过的项目进行测试，那么问题来了，之前我们都是通过配置文件bean.xml来获取Spring的IOC核心容器ApplicationContext，现在注解删了，还怎么获取？3.告知spring的运行器，spring的ioc的创建是基于xml的还是基于注解的，并说明位置。
一、Spring管理类&注入实例
喵酱
03-17 1093
一、Spring是什么？ 用于构建企业级应⽤的轻量级⼀站式解决⽅方案 Spring能帮我们解决什么问题？ 一种胶水，Java开发需要很多很多框架，如果每一个框架的引入都让我们去学习，想想都会令人崩溃 最重要的是，这种每个框架的引入学习本身是没啥太大意义的。真正有意义的是框架的使用与其实现 而Java作为一门免费的语言，其本身并没有去做过多的引入机制和约定。所以这也导致了，各种框架的引入真是千奇百怪 所以Spring用了一种极其优雅的方式帮我们做了这样的事情，慢慢有种海纳百川之势。 各大框架争相恐
Spring入门案例
H_xxxxd的博客
03-09 379
spring
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一麟yl

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值