当前位置： 首页 > wzjs >正文

导购网站建设女生学电子商务好吗

wzjs 2025/7/18 23:12:38
导购网站建设,女生学电子商务好吗,文本中设置网站超链接怎么做,海洋公园网站建设方案新年快乐。 文章目录一、Spring概述1. 为什么要用Spring框架？2. Spring介绍二、IOC/DI快速入门1. IOC控制反转2. DI依赖注入三、Bean的配置1. Bean的基础配置2. Bean的别名配置3. Bean的作用范围配置四、Bean的实例化1. 构造方法方式2. 静态工厂方式3. 实例工厂方式…

在这里插入图片描述

新年快乐。

文章目录

  • 一、Spring概述
    • 1. 为什么要用Spring框架？
    • 2. Spring介绍
  • 二、IOC/DI快速入门
    • 1. IOC控制反转
    • 2. DI依赖注入
  • 三、Bean的配置
    • 1. Bean的基础配置
    • 2. Bean的别名配置
    • 3. Bean的作用范围配置
  • 四、Bean的实例化
    • 1. 构造方法方式
    • 2. 静态工厂方式
    • 3. 实例工厂方式
    • 4. 实现FactoryBean\<T>方式
  • 五、Bean的生命周期
    • 1. Bean的生命周期控制
      • 1.1 提供生命周期控制方法
      • 1.2 实现InitializingBean，DisposableBean接口
    • 2. bean的生命周期控制执行流程
    • 3. Bean的销毁时机
  • 六、依赖注入(DI配置)
    • 1.依赖的注入方式
      • 1.1 setter方式注入
        • 使用set方式注入引用类型（property-ref）
        • 使用set方式注入简单类型（property-value）
      • 1.2 构造方式注入
        • 使用构造方式注入引用类型（ constructor-arg--ref）
        • 使用构造方式注入简单类型（ constructor-arg--value）
        • 参数适配（扩展）
    • 2. 依赖自动装配
    • 3. 集合注入
      • 3.1 注入数组类型数据
      • 3.2 注入List类型数据
      • 3.3 注入Set类型数据
      • 3.4 注入Map类型数据
      • 3.5 注入Properties类型数据

在这里插入图片描述

一、Spring概述

1. 为什么要用Spring框架？

  • Spring 是一款轻量级、非侵入式的开源框架，企业用的人非常多，或者解耦合。
  • Spring可以简化开发，降低企业级开发的复杂度。（IOC控制反转、AOP面向切面编程）
  • Spring可以和许多优秀的框架整合(MyBatis、MP、Struts2、Hibernate、Junit、JPA等等)。

Spring框架应该怎么学：学Spring框架设计思想和基本使用。


2. Spring介绍

Spring官网：https://spring.io/

Spring文档地址：https://docs.spring.io/spring-framework/docs/5.2.10.RELEASE/spring-framework-reference/core.html#spring-core

在这里插入图片描述

Spring 是 JavaEE 领域的一款轻量级、非侵入式的开源框架，该框架由Rod Johnson于 2002 年提出并随后创建（最初版本是interface21）。其目的是为了简化Java企业级应用程序开发的复杂度（简单来讲是解耦合）。

Spring是一个开源容器框架，它集成各类型的工具，通过核心的BeanFactory实现了底层的类的实例化和生命周期的管理。在整个框架中，各类型的功能被抽象成一个个的 Bean，这样就可以实现各种功能的管理，包括动态加载和切面编程。


Spring两大特性：IOC控制反转、AOP面向切面编程。


IOC（Inversion of Control）：控制反转。

  • IoC思想：把之前自己主动new对象的过程，转换成外部提供对象，然后对象创建控制权由自己转移到外部，这就是控制反转。
  • Spring提供了一个容器，称为IOC容器，用来充当IoC思想中的 ''外部"。
  • IOC容器负责对象的创建、初始化等，被创建或被管理的对象在IoC容器中统称为Bean。
  • 控制反转，就是把创建对象的权利交给 Spring管理，我们从Spring中获取对象使用即可。

DI（Dependency Injection）：依赖注入，在IoC容器内将有依赖关系的bean进行关系绑定。（成员变量有两种注入方式：set、构造方法）


AOP：面向切面编程，AOP 用来封装多个类的公共行为，将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。另外，AOP 还解决一些系统层面上的问题，比如日志、事务处理、权限等。


Spring生态

在这里插入图片描述

  • Spring Framework（Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基）。

  • Spring MVC（ Web应用开发）。

  • SpringBoot（它为 Spring 以及第三方库提供一些开箱即用的配置，简化 Spring 应用的搭建及开发过程）。

  • SpringCloud（基于 Spring Boot 实现的微服务框架。它并不是某一门技术，而是一系列微服务解决方案或框架的有序集合。它将市面上成熟的、经过验证的微服务框架整合起来，并通过 Spring Boot 的思想进行再封装，屏蔽掉其中复杂的配置和实现原理，最终为开发人员提供了一套简单易懂、易部署和易维护的分布式系统开发工具包）。

  • Spring Data （数据访问模块，对JDBC和ORM提供了很好的支持。通过它，开发人员可以使用一种相对统一的方式，来访问位于不同类型数据库中的数据）。

  • Spring Security （前身 Acegi，是 Spring 中较成熟的子模块之一，它是一款可以定制化的身份验证和访问控制框架）。

…


Spring Framework系统架构图

Spring Framework是Spring生态圈中最基础的项目，是其他项目的根基。

在这里插入图片描述


二、IOC/DI快速入门

1. IOC控制反转

IOC：控制反转，将bean的创建权交给spring管理。

问题分析：

  • 哪些对象需要管理？(service与dao)

  • 如何将被管理的对象告知IOC容器？(配置文件或注解)

  • 被管理的对象交给IOC容器，如何获取到IoC容器？(使用Spring提供的API)

  • IOC容器得到后，如何从容器中获取bean？(使用Spring提供的API)

  • 使用Spring需要导入哪些依赖坐标？（spring-context）


IOC快速入门：

1、创建一个maven工程。

在这里插入图片描述

在这里插入图片描述


2、导入Spring依赖坐标。

<dependency><groupId>org.springframework</groupId><artifactId>spring-context</artifactId><version>5.2.10.RELEASE</version>
</dependency>

在这里插入图片描述

在这里插入图片描述


3、定义Spring管理的类（接口和实现类）

(1) 编写BookDao接口和BookDaoImpl实现类

package com.baidou.dao;
public interface BookDao {void save();
}

package com.baidou.dao;public class BookDaoImpl implements BookDao {@Overridepublic void save() {System.out.println("bookDao save~");}
}

在这里插入图片描述

(2) 编写BookService接口和BookServiceImpl实现类

package com.baidou.service;public interface BookService {void save();
}

package com.baidou.service;import com.baidou.dao.BookDao;
import com.baidou.dao.BookDaoImpl;public class BookServiceImpl implements BookService {// 传统的依赖注入写法:直接在成员变量处创建对象、为成员变量提供set方法、通过构造器为成员变量初始化private BookDao bookDao = new BookDaoImpl(); @Overridepublic void save() {System.out.println("bookService save...");bookDao.save();}
}

在这里插入图片描述


4、创建spring配置文件，配置spring管理的bean对象。

在这里插入图片描述

定义applicationContext.xml配置文件，并对并BookServiceImpl进行配置。

<?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标签:用于配置bean对象的id属性:给bean起名字的(名字唯一)class属性:定义bean的类型--><bean id="bookService" class="com.baidou.service.BookServiceImpl"></bean></beans>

在这里插入图片描述

注意事项：bean定义时，id属性在同一个spring配置文件(IOC容器中)不能重复出现。


5、初始化IOC容器（Spring容器），通过容器获取Bean对象。

package com.baidou;import com.baidou.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Application {public static void main(String[] args) {// 1.创建IoC容器对象,加载spring核心配置文件ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");//System.out.println(ctx);//org.springframework.context.support.ClassPathXmlApplicationContext@1d56ce6a 表示ioc容器对象已经成功创建// 2. 从IOC容器中获取Bean对象  (例如我们配置的BookService对象)BookService bookService = (BookService) ctx.getBean("bookService"); // 通过id获取bean// 也可以通过name获取bean// 也可以通过类型获取bean: ctx.getBean(BookService.class)// 3.调用Bean对象(BookService对象)的方法bookService.save();}
}

在这里插入图片描述


2. DI依赖注入

DI：依赖注入，在spring容器中将bean的依赖关系绑定。（给bean设置成员变量）

DI使用分析：

  • 基于IoC管理bean。
  • service中需要使用dao对象，如何引入？（提供方法，set方法或者构造器）
  • 通过一些配置来描述service和dao之间的关系。

DI快速入门：

1、为成员变量提供setter方法

package com.baidou.service;import com.baidou.dao.BookDao;
import com.baidou.dao.BookDaoImpl;public class BookServiceImpl implements BookService {//   private BookDao bookDao=new BookDaoImpl();private BookDao bookDao;// 提供set方法public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}@Overridepublic void save() {System.out.println("bookService save...");bookDao.save();}
}

在这里插入图片描述


2、在spring配置文件中，配置service与dao的依赖关系。

<?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"><!--bookService bean--><bean id="bookService" class="com.baidou.service.BookServiceImpl"><!--property标签: 为bean设置属性name属性: 指向bean的属性名（必须有set方法）ref 属性: 指向bean容器中的那个对象 (此处写bean的名字即可)--><!--将容器中名字为bookDao的bean设置给bookService中的bookDao属性--><property name="bookDao" ref="bookDao"/></bean><!--bookDao bean--><bean id="bookDao" class="com.baidou.dao.BookDaoImpl"></bean></beans>

注意：在spring中通过setter注入的属性的话，就必须为该属性提供对应的set方法。


3、测试

在这里插入图片描述


三、Bean的配置

1. Bean的基础配置

<bean id="bookService" class="com.baidou.service.BookServiceImpl"></bean>
<bean id="bookDao" class="com.baidou.dao.BookDaoImpl"></bean>
  • bean标签的作用：定义bean对象，让Sring容器管理。这个标签所属beans标签。
  • id属性：bean的id，在容器中通过id值获取对应的bean，在一个容器中id值是唯一的。
  • class属性：bean的类型，即配置bean的全路径类名。

2. Bean的别名配置

我们知道bean标签的id属性可以定义bean的名字，那么name属性就可以定义bean的别名。

bean的别名可以定义多个，多个别名之间用 逗号(,)、分号(; ) 、空格分隔。

<bean id="bookService" name="service bookServiceImpl" class="com.baidou.service.BookServiceImpl"></bean>
<bean name="dao,bookDaoImpl" class="com.baidou.dao.BookDaoImpl"></bean>

注意：无论通过id还是name获取bean，如果容器中找不到bean，就会抛出异常：NoSuchBeanDefinitionException。（没有这样的bean）

在这里插入图片描述


示例：别名的使用

在这里插入图片描述

在这里插入图片描述


3. Bean的作用范围配置

通过bean标签的scope属性定义bean作用范围，常用的scope属性值有：

  • singleton：单例（ioc容器管理的对象默认是单例的，就不用配置scope属性）
  • prototype：非单例（需要配置scope属性，表示每次都能获取不同的对象，通过地址值判断）

扩展：scope的取值不仅仅只有singleton和prototype，还有request、session、global session等 ，表示创建出的对象放置在web容器(tomcat)对应的位置。比如：request表示保存到request域中。

示例：

在这里插入图片描述

在这里插入图片描述


小结

bean的配置：

  • scope:作用范围(单实例还是多实例) 默认单实例。

  • name:别名。（不常用）

  • init-method和destory-method:生命周期。（了解即可）


四、Bean的实例化

传统创建对象的方式：

  • new 类名() ; // 调用无参构造器。
  • 工厂类.方法()； // 调用某个类的静态方法
  • 某个对象.方法(); //调用某个对象的普通方法创建目标对象。例如 sqlSessionFactory.openSession();
  • 反射
  • 序列化
  • …

Bean的实例化方式有四种：构造方法方式、静态工厂方式、实例工厂方式、实现FactoryBean<T>方式（扩展）。

1. 构造方法方式

bean本质上就是对象，可以通过构造方法方式实例化bean。（重点）

1、为实现类BookDaoImpl提供一个构造方法

public class BookDaoImpl implements BookDao {// 显示定义一个无参构造方法public BookDaoImpl() {System.out.println("bookDao的构造方法执行了~");}@Overridepublic void save() {System.out.println("bookDao save~");}
}

2、配置bean：

<?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 --><bean id="bookDao" class="com.baidou.dao.BookDaoImpl"/>
</beans>

3、编写测试

public class Application {public static void main(String[] args) {// 创建IOC容器对象,并加载spring核心配置文件ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");// 获取容器中的bean对象BookDao bookDao = (BookDao) ctx.getBean("bookDao");//  调用bean的方法bookDao.save();}
}

在这里插入图片描述


注意：如果定义了有参构造器方法，没有提供无参构造方法，就会抛出异常：BeanInstantiationException（bean实例化异常）

在这里插入图片描述

在这里插入图片描述


2. 静态工厂方式

通过示例静态工厂方式实例化bean。

1、定义接口和实现类

package com.baidou.dao;public interface OrderDao {public void save();
}

package com.baidou.dao;public class OrderDaoImpl implements OrderDao {public void save() {System.out.println("orderDao save ...");}
}

2、编写工厂类

package com.baidou.factory;import com.baidou.dao.OrderDao;
import com.baidou.dao.OrderDaoImpl;// 静态工厂创建对象
public class OrderDaoFactory {public static OrderDao getOrderDao() {return new OrderDaoImpl() ;}
}

3、在applicationContext.xml中，配置bean:

<?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 --><bean id="orderDao" class="com.baidou.factory.OrderDaoFactory" factory-method="getOrderDao"/></beans>

在这里插入图片描述


4、编写测试

package com.baidou;import com.baidou.dao.OrderDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class Application {public static void main(String[] args) {// 创建IOC容器对象,并加载spring核心配置文件ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");// 获取容器中的bean对象OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");//  调用bean的方法orderDao.save();}
}

在这里插入图片描述


3. 实例工厂方式

通过实例工厂方式实例化bean。

1、定义接口和实现类

package com.baidou.dao;public interface UserDao {public void save();
}

package com.baidou.dao;public class UserDaoImpl implements UserDao {@Overridepublic void save() {System.out.println("userDao save ...");}
}

2、编写工厂类

package com.baidou.factory;import com.baidou.dao.UserDao;
import com.baidou.dao.UserDaoImpl;//实例工厂创建对象
public class UserDaoFactory {public UserDao getUserDao(){return new UserDaoImpl();}
}

3、在applicationContext.xml中，配置bean:

<?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--><!-- 配置实例工厂的bean--><bean id="userFactory" class="com.baidou.factory.UserDaoFactory"/><!--调用工厂对象的普通方法创建userDao对象--><bean id="userDao"  factory-bean="userFactory" factory-method="getUserDao"></bean></beans>

在这里插入图片描述


4、编写测试

public class Application {public static void main(String[] args) {// //创建实例工厂对象// UserDaoFactory userDaoFactory = new UserDaoFactory();// //通过实例工厂对象创建对象// UserDao userDao = userDaoFactory.getUserDao();// userDao.save();ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao = (UserDao) ctx.getBean("userDao");userDao.save();}
}

在这里插入图片描述


4. 实现FactoryBean<T>方式

spring底层会用

1、定义UserDaoFactoryBean类，去实现FactoryBean<UserDao>接口。

  • UserDaoFactoryBean中实例化什么类型的对象，泛型就设置对应的类型。
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {// 重写接口中的两个方法//代替原始实例工厂中创建对象的方法public UserDao getObject() throws Exception {return new UserDaoImpl();}public Class<?> getObjectType() {return UserDao.class;}
}

2、配置bean：

<?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">	<!--方式四：使用FactoryBean实例化bean--><!--factoryBean:创建对象的时候,spring会判断当前类有无实现factoryBean接口,若实现了，就会调用两个方法创建目标对象，且将对象放入spring容器管理		--><bean id="userDao" class="com.baidou.factory.UserDaoFactoryBean"/>
<beans/>

3、编写测试：

public class Application {public static void main(String[] args) {ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");UserDao userDao = (UserDao) ctx.getBean("userDao");userDao.save();}
}

在这里插入图片描述


小结：

bean实例化方式：构造器方式（无参构造）。


五、Bean的生命周期

生命周期：就是从创建到消亡的完整过程。

bean生命周期：bean从创建到销毁的整体过程。

bean生命周期控制：bean从创建后到销毁前做一些事情。

1. Bean的生命周期控制

1.1 提供生命周期控制方法

1、提供声明周期方法（init和destory方法）

public class BookDaoImpl implements BookDao {public void save() {System.out.println("bookDao save ...");}//表示bean初始化对应的操作public void init(){System.out.println("init...");}//表示bean销毁前对应的操作public void destory(){System.out.println("destory...");}
}

2、在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 http://www.springframework.org/schema/beans/spring-beans.xsd"><!--init-method：设置bean初始化生命周期回调函数,此处填写init方法名--><!--destroy-method：设置bean销毁生命周期回调函数，仅适用于单例对象，此处填写destory方法名--><bean id="bookDao" class="com.baidou.dao.BookDaoImpl" init-method="init" destroy-method="destory"/></beans>

3、编写测试

public class App {public static void main(String[] args) {ClassPathXmlApplicationContext ctx =  new ClassPathXmlApplicationContext("applicationContext.xml");ctx.registerShutdownHook(); //优雅的关闭容器写法:先注册一下,当这些代码全部执行完毕后就销毁容器BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();// 若想执行destory销毁方法,需要关闭spring容器//ctx.close(); //缺点:close()方法必须放在最后一行执行}
}
/*当创建spring容器的时候,默认它会将配置文件中的所有单实例对象都创建好,且放入spring容器中;若配置init-method、destroy-method,就会去调用指定的方法。
*/

在这里插入图片描述

单实例的话，也可以在bean标签中配置lazy-init="true"，表示用的时候创建bean。


多实例的话，用的时候才会去创建bean，bean的销毁由垃圾回收机制处理。

在这里插入图片描述


1.2 实现InitializingBean，DisposableBean接口

实现InitializingBean、DisposableBean接口，重写接口中的两个方法:destroy、afterPropertiesSet

package com.baidou.dao;import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;public class BookDaoImpl implements BookDao, InitializingBean, DisposableBean {public BookDaoImpl() {System.out.println("bookDao 无参构造方法执行了");}public void save() {System.out.println("bookDao save ...");}// 在bean对象销毁前要执行的方法@Overridepublic void destroy() throws Exception {System.out.println("destroy ...");}// 在bean设置完属性之后会执行的方法 （相当于init-method配置）@Overridepublic void afterPropertiesSet() throws Exception {System.out.println("init ...");}
}

<?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="bookDao" class="com.baidou.dao.BookDaoImpl"></bean></beans>

public class App {public static void main(String[] args) {ClassPathXmlApplicationContext ctx =  new ClassPathXmlApplicationContext("applicationContext.xml");ctx.registerShutdownHook(); //优雅的关闭容器方式:先注册一下,当这些代码全部执行完毕后就销毁容器BookDao bookDao = (BookDao) ctx.getBean("bookDao");bookDao.save();}
}

在这里插入图片描述


2. bean的生命周期控制执行流程

1、初始化容器

2、创建对象（内存分配）

3、执行构造方法

4、执行属性注入（set操作）

5、执行bean初始化方法：

  • 若在bean中配置了init-method，就会执行指定的方法。
  • 若实现了InitializingBean接口的话就会执行afterPropertiesSet。

6、使用bean执行业务操作

7、关闭/销毁容器之前执行bean销毁方法：

  • 若实现了DisposableBean接口的话，就会执行destroy方法。
  • 若在bean中配置了destroy-method的话就会执行指定的方法。

3. Bean的销毁时机

IOC容器关闭前才会触发bean的销毁。

关闭容器的两种方式：

1、手动关闭容器：通过ConfigurableApplicationContext接口的close()方法。

2、注册关闭钩子，在虚拟机退出前先关闭容器再退出虚拟机：通过ConfigurableApplicationContext接口的registerShutdownHook()方法。


六、依赖注入(DI配置)

1.依赖的注入方式

依赖注入有两种方式：setter方式、构造器方式。

1.1 setter方式注入

setter方式：

  • 在类中提供给成员变量提供setter方法。
  • 在配置文件中通过 <property name=“属性名” ref|value=“”/>。
  • ref:注入引用类型。
  • value:注入简单类型。

使用set方式注入引用类型（property-ref）

package com.baidou.service;import com.baidou.dao.BookDao;public class BookServiceImpl implements BookService {private BookDao bookDao;// 为成员变量提供set方法public void setBookDao(BookDao bookDao) {this.bookDao = bookDao;}@Overridepublic void save() {System.out.println("bookService save...");}
}

<!--bookService -->
<bean id="bookService" class="com.baidou.service.BookServiceImpl"><!--使用property标签的ref属性注入引用类型对象--><property name="bookDao" ref="bookDao"></property>
</bean><!--bookDao-->
<bean class="com.baidou.dao.BookDaoImpl" id="bookDao"></bean>

在这里插入图片描述


使用set方式注入简单类型（property-value）

package com.baidou.dao;public class BookDaoImpl implements BookDao {// 定义简单类型成员变量private int connectionNumber;// 提供set方法public void setConnectionNumber(int connectionNumber) {this.connectionNumber = connectionNumber;}public void save() {System.out.println("bookDao save ...");}
}

<bean class="com.baidou.dao.BookDaoImpl" id="bookDao"><!-- 使用property标签的value属性注入简单类型--><property name="connectionNumber" value="10"/>
</bean>

在这里插入图片描述


1.2 构造方式注入

构造器方式：

  • 在类中提供给成员变量赋值的构造器。
  • 在配置文件中通过 <constructor-arg name=“参数名字” ref|value=“”/>。
  • ref:注入引用类型。
  • value:注入简单类型。

使用构造方式注入引用类型（ constructor-arg–ref）

package com.baidou.service;import com.baidou.dao.BookDao;public class BookServiceImpl implements BookService {private BookDao bookDao;// 提供无参构造器public BookServiceImpl() {}//  通过带参构造器public BookServiceImpl(BookDao bookDao) {this.bookDao = bookDao;}@Overridepublic void save() {System.out.println("bookService save...");}
}

<!--bookService -->
<bean id="bookService" class="com.baidou.service.BookServiceImpl"><!--通过constructor-arg标签的ref属性注入引用类型对象--><constructor-arg name="bookDao" ref="bookDao"/>
</bean><!--bookDao-->
<bean class="com.baidou.dao.BookDaoImpl" id="bookDao"></bean>

在这里插入图片描述


使用构造方式注入简单类型（ constructor-arg–value）

public class BookDaoImpl implements BookDao {// 定义简单类型成员变量private int connectionNumber;private String databaseName;// 提供无参构造器public BookDaoImpl() {}// 提供带参构造器public BookDaoImpl(int connectionNumber, String databaseName) {this.connectionNumber = connectionNumber;this.databaseName = databaseName;}public void save() {System.out.println("bookDao save ...");}
}

<bean class="com.baidou.dao.BookDaoImpl" id="bookDao"><!--通过constructor-arg标签的value属性注入简单类型数据--><constructor-arg name="connectionNumber" value="10"/><constructor-arg name="databaseName" value="redis"/>
</bean>

在这里插入图片描述


参数适配（扩展）

1、通过constructor-arg标签的type属性设置按照形参类型注入：

在这里插入图片描述

<!--bookDao-->
<bean class="com.baidou.dao.BookDaoImpl" id="bookDao"><constructor-arg type="int" value="10"/><constructor-arg type="java.lang.String" value="redis"/>
</bean>

2、通过constructor-arg标签的index属性设置按照形参位置注入：

<!--bookDao-->
<bean class="com.baidou.dao.BookDaoImpl" id="bookDao"><constructor-arg index="0" value="10"/><constructor-arg index="1" value="mysql"/>
</bean>

依赖注入方式选择：

  1. 强制依赖使用构造器进行，使用setter注入有概率导致null对象出现。
  2. 可选依赖使用setter注入进行，灵活性强。
  3. Spring框架倡导使用构造器，第三方框架内部大多数采用构造器注入的形式进行数据初始化，相对严谨。
  4. 如果有必要可以两者同时使用，使用构造器注入完成强制依赖的注入，使用setter注入完成可选依赖的注入。
  5. 实际开发过程中还要根据实际情况分析，如果受控对象没有提供setter方法就必须使用构造器注入。
  6. 自己开发的模块推荐使用setter注入。

2. 依赖自动装配

IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配。（后面会用@autowire注解实现）

自动装配方式有：

  • 按类型进行装配（常用）
  • 按名称进行装配
  • 按构造方法进行装配
  • 不启用自动装配

在配置文件中，通过bean标签的autowire属性设置自动装配的类型：（给成员变量提供setter方法）

<bean id="bookDao" class="com.baidou.dao.BookDaoImpl"/>
<bean id="bookService" class="com.baidou.service.BookServiceImpl" autowire="byType"/>

依赖自动装配特征:

  1. 自动装配用于引用类型依赖注入，不能对简单类型进行操作。
  2. 使用按类型装配时（byType）必须保障容器中相同类型的bean唯一，推荐使用。
  3. 使用按名称装配时（byName）必须保障容器中具有指定名称的bean，因变量名与配置耦合，不推荐使用。
  4. 自动装配优先级低于setter注入与构造器注入，同时出现时自动装配配置失效。

3. 集合注入

property标签通过setter方式注入，内部可以写<array>、<list>、<set>、<map>、<props>标签。

constructor-arg标签通过构造方式注入，constructor-arg标签内部也可以写<array>、<list>、<set>、<map>、<props>标签。

单列集合:array、set、list。

双列集合:map、props。

3.1 注入数组类型数据

<property name="array"><array><value>1</value><value>2</value><value>3</value></array>
</property>

3.2 注入List类型数据

<property name="list"><list><value>java</value><value>php</value><value>python</value><value>c++</value></list>
</property>

3.3 注入Set类型数据

<property name="set"><set><value>java</value><value>php</value><value>python</value><value>java</value></set>
</property>

3.4 注入Map类型数据

<property name="map"><map><entry key="country" value="china"/><entry key="province" value="zhejiang"/><entry key="city" value="hangzhou"/></map>
</property>

3.5 注入Properties类型数据

<property name="properties"><props><prop key="country">china</prop><prop key="province">zhejiang</prop><prop key="city">hangzhou</prop></props>
</property>
http://www.dtcms.com/wzjs/4184.html

相关文章：

  • 网站建设与运营合同网站建网站建设网站
  • 光谷企业网站建设软文广告发布平台
  • 网站想换个风格怎么做seo就业
  • 怎么做独立网站营销推广费用预算表
  • 门户网站开发技术运营商大数据精准营销
  • 青海做网站公司百度入口网址
  • 2014山东春季高考网站建设app排名优化公司
  • 阿里巴巴做网站费用经典营销案例
  • 评价中国建设银行网站惠州seo推广外包
  • 四川省建设工程质量监理协会网站长沙关键词快速排名
  • 江宁招网站建设58网站制作建设
  • 河北省住房及城乡建设部网站大专网络营销专业好不好
  • 湖南省政府网站注册平台
  • 网站屏蔽ip广州最新疫情通报
  • 宿州网站建设怎么投放广告
  • 百度自动优化班级优化大师下载
  • 网站设计实验目的网销怎么销售的
  • 在政府网站建设会上的主持词深圳网络推广团队
  • 自己做网站要多少钱seo网站推广工作内容
  • 外包手工活在哪里拿货seo网站分析工具
  • wordpress头部优化铜川网站seo
  • 免费logo图标在线制作 设计苏州首页关键词优化
  • 青岛慧思网站建设咖啡seo是什么意思
  • 网站建设的一般步骤包括关键词查网站
  • wordpress调用列表网络优化app
  • 做简历的什么客网站上海优化seo公司
  • 西安建站网站互联网营销师是干什么的
  • 电商的网站怎么做的好网络推广的方法你知道几个?
  • 手机在线编程网站临沂seo整站优化厂家
  • 手机网站设计立找亿企邦江门网站建设