java框架注入是创建对象吗_spring(1)(用spring控制创建对象的细节，创建和注入的方式）...

最新推荐文章于 2021-12-08 16:04:27 发布

曹文雯

最新推荐文章于 2021-12-08 16:04:27 发布

阅读量198

点赞数

文章标签： java框架注入是创建对象吗

本文链接：https://blog.csdn.net/weixin_32060671/article/details/114814914

版权

本文详细介绍了Spring框架的核心功能——控制反转(IOC)和依赖注入(DI)，探讨了对象的创建、依赖关系的处理以及Spring如何与其他框架如Struts和Hibernate集成。此外，还讨论了Spring的版本特点、开发步骤、配置文件以及各种创建对象和处理依赖关系的方式，包括构造器、set方法、p命名空间、自动装配等，并提到了注解方式简化配置的应用。

摘要由CSDN通过智能技术生成

回顾:Struts与Hibernate可以做什么事？

Struts，

Mvc中控制层解决方案

可以进行请求数据自动封装、类型转换、文件上传、效验…

Hibernate,

持久层的解决方案；

可以做到，把对象保存到数据库，从数据库中取出的是对象。

Spring框架

传统的方式，对象创建都是写死的。关于对象创建细节：

1.对象数量：单例，多个

2.创建时间：

action 访问时候创建

service 启动时候创建

dao 启动时候创建

3.对象的依赖关系：service依赖 dao

spring简单来说，就是处理对象的创建的、以及对象的依赖关系！

组件/框架设计

侵入式设计:

引入了框架，对现有的类的结构有影响；即需要实现或继承某些特定类。

例如：Struts框架

非侵入式设计:

引入了框架，对现有的类结构没有影响。

例如：Hibernate框架/ Spring框架

Inversion on Control , 控制反转 IOC

对象的创建交给外部容器完成，这个就做控制反转.(一个类需要一个对象，不在本类中创建)

依赖注入， dependency injection

处理对象的依赖关系(一个类需要一个对象，拿过来的过程)

IOC/DI区别：

控制反转，解决对象创建的问题【对象创建交给别人】

依赖注入，在创建完对象后，对象的关系的处理就是依赖注入【通过set方法依赖注入】

AOP

面向切面编程，切面举例：事务、日志、权限;

Spring框架：

可以解决对象创建以及对象之间依赖关系的一种框架。

且可以和其他框架一起使用；Spring与Struts, Spring与hibernate

(起到整合(粘合)作用的一个框架)

Spring提供了一站式解决方案：

1) Spring Core spring的核心功能： IOC容器, 解决对象创建及依赖关系2) Spring Web Spring对web模块的支持。可以与struts整合,让struts的action创建交给springspring mvc模式3) Spring DAO Spring 对jdbc操作的支持【JdbcTemplate模板工具类】4) Spring ORM spring对orm的支持：

既可以与hibernate整合，【session】

也可以使用spring的对hibernate操作的封装5)Spring AOP 切面编程6)SpringEE spring 对javaEE其他模块的支持

spring各个版本中：

在3.0以下的版本，源码有spring中相关的所有包【spring功能 +依赖包】如2.5版本；

在3.0以上的版本，源码中只有spring的核心功能包【没有依赖包】

(如果要用依赖包，需要单独下载！)

开发步骤：

1) 源码, jar文件：spring-framework-3.2.5.RELEASE

commons-logging-1.1.3.jar 日志

spring-beans-3.2.5.RELEASE.jar bean节点

spring-context-3.2.5.RELEASE.jar spring上下文节点

spring-core-3.2.5.RELEASE.jar spring核心功能

spring-expression-3.2.5.RELEASE.jar spring表达式相关表

以上是必须引入的5个jar文件，在项目中可以用户库管理！

2) 核心配置文件: applicationContext.xml

Spring配置文件命名方式：

applicationContext.xml / bean.xml

配置约束可以参考文档：spring-framework-3.2.5.RELEASE\docs\spring-framework-reference\htmlsingle\index.html

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

View Code

实例:

applicationContext.xml(有时候创建的对象称bean对象是因为spring都是通过配置bean标签来得到对象)

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

测试类：

public classTest {//1. 通过工厂类得到IOC容器创建的对象

@Testpublic void testIOC() throwsException {//创建对象//User user = new User();//现在，把对象的创建交给spring的IOC容器

Resource resource = new ClassPathResource("cn/itcast/a_hello/applicationContext.xml");//创建容器对象(Bean的工厂), IOC容器 = 工厂类 + applicationContext.xml

BeanFactory factory = newXmlBeanFactory(resource);//得到容器创建的对象

User user = (User) factory.getBean("user");

System.out.println(user.getId());

}//2. (方便)直接得到IOC容器对象

@Testpublic void testAc() throwsException {//得到IOC容器对象

ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");//从容器中获取bean

User user = (User) ac.getBean("user");

System.out.println(user);

}}

spring控制对象创建的细节

applicationContext.xml配置参数的作用：

1) 对象创建数量：单例/多例scope="singleton", 默认值，即默认是单例【service/dao/工具类】scope="prototype", 多例；【Action对象】2) 什么时候创建?

scope="prototype"在用到对象的时候，才创建对象。scope="singleton"在启动(容器初始化)，就已经创建了bean，且整个应用只有一个。(单例想延迟初始化可以配置lazy-init=true)3)是否延迟创建(该属性只是针对单例) lazy-init="false"(可不写)默认, 不延迟创建，即在启动时候就创建对象 lazy-init="true"延迟初始化，在用到对象的时候才创建对象(只对单例有效)4) 创建对象之后，指定对象初始化/销毁时调用的方法。 init-method="init_user"【对应对象的init_user方法，在对象创建之后执行】 destroy-method="destroy_user" 【在调用容器对象的destriy方法时候执行，(容器用实现类ClassPathXmlApplicationContext】

实例：

public classUser {private intid;privateString name;publicUser() {super();

System.out.println("------User对象创建------");

}public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}public voidinit_user() {

System.out.println("创建对象之后，初始化");

}public voiddestroy_user() {

System.out.println("IOC容器销毁，user对象回收!");

}

配置：

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

测试类:

public void testIOC() throwsException {//得到IOC容器对象【用实现类，因为要调用销毁的方法】

ClassPathXmlApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/a_hello/applicationContext.xml");

System.out.println("-----容器创建-----");//从容器中获取bean

User user1 = (User) ac.getBean("user");

User user2= (User) ac.getBean("user");

System.out.println(user1);

System.out.println(user2);//销毁容器对象 (ClassPathXmlApplicationContext类才有销毁方法)

ac.destroy();

}

spring实现创建对象的方式：

SpringIOC容器，是spring核心内容。

作用：创建对象 & 处理对象的依赖关系

IOC容器创建对象：有几种方式：

1) 调用无参数构造器

2) 带参数构造器

3) 工厂创建对象

工厂类，静态方法创建对象

工厂类，非静态方法创建对象

实例：

User.java

public classUser {private intid;privateString name;publicUser() {super();

System.out.println("------User对象创建【无参数构造器】------");

}public User(intid, String name) {

System.out.println("-----User对象创建【带参数构造器】--------");this.id =id;this.name =name;

}public intgetId() {returnid;

}public void setId(intid) {this.id =id;

}publicString getName() {returnname;

}public voidsetName(String name) {this.name =name;

}

@OverridepublicString toString() {return "User [id=" + id + ", name=" + name + "]";

}public voidinit_user() {

System.out.println("创建对象之后，初始化");

}public voiddestroy_user() {

System.out.println("IOC容器销毁，user对象回收!");

}

View Code

ObjectFactory.java

//工厂，创建对象

public classObjectFactory {//实例方法创建对象

publicUser getInstance() {return new User(100,"工厂：调用实例方法");

}//静态方法创建对象

public staticUser getStaticInstance() {return new User(101,"工厂：调用静态方法");

}

bean.xml(配置文件名字可以自定义，可以放在src下也可以在包下)

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

测试类：

public void testIOC() throwsException {//创建IOC容器对象

ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/b_create_obj/bean.xml");//获取容器中的对象

User user = (User) ac.getBean("user");

System.out.println(user);

}

处理对象依赖关系,Spring给对象的属性赋值【DI, 依赖注入】

(对象依赖的数据存放在属性中，属性可以是对象和基本类型，而将这些数据赋值给这些属性的过程就是依赖注入)

注入的方式有:

1) 通过构造函数2) 通过set方法给属性注入值3) p名称空间4) 自动装配(了解)5) 注解

构造函数，set属性,p名称空间的方式实例:

User.java

public classUser {private intid;privateString name;//--> 通过容器注入属性值

public void setId(intid) {this.id =id;

}// //--> 通过容器注入属性值

public voidsetName(String name) {this.name =name;

}public intgetId() {returnid;

}publicString getName() {returnname;

}

@OverridepublicString toString() {return "User [id=" + id + ", name=" + name + "]";

}publicUser() {super();

System.out.println("------User对象创建【无参数构造器】------");

}public User(intid, String name) {

System.out.println("-----User对象创建【带参数构造器】--------");this.id =id;this.name =name;

}

View Code

UserAction.java

public classUserAction {//Service: springIOC容器注入

privateUserService userService;public voidsetUserService(UserService userService) {this.userService =userService;

}publicString execute() {

userService.save();return null;

}

View Code

UserDao.java

public classUserDao {public voidsave() {

System.out.println("DB:保存用户");

}

View Code

UserService.java

public classUserService {private UserDao userDao; //= new UserDao();//IOC：对象的创建交给spring的外部容器完成

public voidsetUserDao(UserDao userDao) {this.userDao =userDao;

}public voidsave() {

userDao.save();

}

View Code

bean.xml

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

测试类：

public classApp {//创建容器对象

private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_property/bean.xml");

@Testpublic voidtestSet() {//从容器中获取

User user = (User) ac.getBean("user");

System.out.println(user);

}

@Testpublic voidtestExecuteAction() {//从容器中获取Action

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();

}}

bean_p.xml(采用命名空间的标签的方式，属性对象也需要set方法)：

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

测试类：

//创建容器对象

private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/c_property/bean_p.xml");

@Testpublic voidtestExecuteAction() {//从容器中获取Action

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();

System.out.println(ac.getBean("user"));

}

自动装配方式，分为：根据名称和类型自动装配(属性对象也需要set方法)

1.根据名称自动装配：autowire="byName"(自动去IOC容器(bean.xml配置)中找与属性名同名的引用的对象，并自动注入)

也可以定义到全局，这样就不用每个bean节点都去写autowire=”byName”

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd"default-autowire="byName">根据名称自动装配(全局)

2.根据类型自动装配：autowire="byType"(必须确保依赖的类型在IOC容器中只有一个配置；否则报错)

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd"default-autowire="byType">

(一般不推荐使用)Spring提供的自动装配简化配置，但是不利于后期的维护。(应该是依赖关系的可读性比较差，需要从类中确定)

测试类：

//创建容器对象

private ApplicationContext ac =

new ClassPathXmlApplicationContext("cn/itcast/d_auto/bean.xml");

@Testpublic voidtestExecuteAction() {//从容器中获取Action

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();

}

View Code

注解方式，简化spring的IOC容器的配置

(注解的方式，属性对象不用提供set方法)

使用注解步骤：

1)先引入context名称空间：xmlns:context="http://www.springframework.org/schema/context"

2)开启注解扫描：

3)代码中使用注解

代码中相关的注解：Component/Resource

@Component ：指定把一个对象加入IOC容器(还可以这样写@Component(‘属性名’)，意思加入并且取名为xxx)

@Repository 作用同@Component；在持久层使用(这样写，好像只是增强了可读性，层次比较清晰)

@Service 作用同@Component；在业务逻辑层使用

@Controller 作用同@Component；在控制层使用

@Resource ：属性注入，根据类型注入(还可以这样写@Resource(name="xxx")注入名为xxx的对象)

实例：

UserAction.java

//@Component("userAction")//加入IOC容器//@Component

@Controller //控制层的组件

public classUserAction {

@ResourceprivateUserService userService;publicString execute() {

userService.save();return null;

}

View Code

UserDao.java(注解被注释掉了，是为测试注解和bean配置共同使用的情况)

//把当前对象加入ioc容器//@Component("userDao")//相当于bean.xml 【】//@Component//加入ioc容器的UserDao对象的引用名称，默认与类名一样，且第一个字母小写//@Repository//在持久层可以选择用这个注解

public classUserDao {publicUserDao(){

System.out.println("UserDao.UserDao()");

}public UserDao(intid){

System.out.println("UserDao.UserDao(int id)" +id);

}public voidsave() {

System.out.println("DB:保存用户!!!");

}

View Code

UserService.java

//@Component("userService")//userService加入ioc容器//@Component

@Service //表示业务逻辑层的组件

public classUserService {//@Resource//根据类型查找【在容器中要确保该类型只有一个变量，针对的是注解和配置bean一起使用的情况，如果都是采用注解，只会一个类型加入IOC容器】

@Resource(name = "userDao")//根据名称查找

private UserDao userDao; //去容器中招UserDao类型的变量，找到后就赋值

public voidsave() {

userDao.save();

}

bean.xml

http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans.xsd

http://www.springframework.org/schema/context

http://www.springframework.org/schema/context/spring-context.xsd">

//注释掉了userDao中注解(注解和配置bean可以互补的方式共同使用)

测试类：

//创建容器对象

private ApplicationContext ac = new ClassPathXmlApplicationContext("cn/itcast/e_anno2/bean.xml");

@Testpublic voidtestExecuteAction() {//从容器中获取Action

UserAction userAction = (UserAction) ac.getBean("userAction");

userAction.execute();

}

总结：

一种更加简便的依赖注入方式，那就是注解加自动装配，加入容器的对象添加注解，依赖的对象注入交给自动装配的方式注入(这样依赖的属性对象不用写注解，但需要写set方法，因为交个自动装配的方式)

曹文雯

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫