我要评论1.创建工程
1.1.pom.xml
<?xml version="1.0" encoding="utf-8"?>
<project xmlns="http://maven.apache.org/pom/4.0.0"
xmlns:xsi="http://www.w3.org/2001/xmlschema-instance"
xsi:schemalocation="http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelversion>4.0.0</modelversion>
<groupid>com.by</groupid>
<artifactid>spring_ioc_xml</artifactid>
<version>1.0-snapshot</version>
<properties>
<!-- 项目源码及编译输出的编码 -->
<project.build.sourceencoding>utf-8</project.build.sourceencoding>
<project.reporting.outputencoding>utf-8</project.reporting.outputencoding>
<!-- 项目编译jdk版本 -->
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>
<dependencies>
<!-- spring常用依赖 -->
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-context</artifactid>
<version>5.1.8.release</version>
</dependency>
</dependencies>
</project>注意：jar包彼此存在依赖，只需引入最外层jar即可由maven自动将相关依赖jar引入到项目中。
spring常用功能的jar包依赖关系:
核心容器由 beans、core、context 和 expression（spring expression language，spel）4个模块组成。
spring-beans和spring-core模块是spring框架的核心模块，包含了控制反转（inversion of control，ioc）和依赖注入（dependency injection，di）。beanfactory使用控制反转对应用程序的配置和依赖性规范与实际的应用程序代码进行了分离。beanfactory属于延时加载，也就是说在实例化容器对象后并不会自动实例化bean，只有当bean被使用时，beanfactory才会对该 bean 进行实例化与依赖关系的装配。
spring-context模块构架于核心模块之上，扩展了beanfactory，为它添加了bean生命周期控制、框架事件体系及资源加载透明化等功能。此外，该模块还提供了许多企业级支持，如邮件访问、远程访问、任务调度等，applicationcontext 是该模块的核心接口，它的超类是 beanfactory。与beanfactory不同，applicationcontext实例化后会自动对所有的单实例bean进行实例化与依赖关系的装配，使之处于待用状态。
spring-expression 模块是统一表达式语言（el）的扩展模块，可以查询、管理运行中的对象，同时也可以方便地调用对象方法，以及操作数组、集合等。它的语法类似于传统el，但提供了额外的功能，最出色的要数函数调用和简单字符串的模板函数。el的特性是基于spring产品的需求而设计的，可以非常方便地同spring ioc进行交互。
1.2.dao
/**
* 持久层实现类
*/
public class userdaoimpl implements userdao {
@override
public void adduser(){
system.out.println("insert into tb_user......");
}
}1.3.service
/**
* 业务层实现类
*/
public class userserviceimpl implements userservice {
//此处有依赖关系
private userdao userdao = new userdaoimpl();
public void adduser(){
userdao.adduser();
}
}2.ioc
2.1.applicationcontext.xml
<?xml version="1.0" encoding="utf-8"?>
<!--1、注意：要导入schema约束-->
<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">
<!--
2、把对象交给spring来创建
id：给对象在容器中提供一个唯一标识。用于获取对象
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数
-->
<bean id="userdao" class="com.by.dao.userdaoimpl"></bean>
<bean id="userservice" class="com.by.service.userserviceimpl"></bean>
</beans>注意：命名无限制，约定俗成命名有：spring-context.xml、applicationcontext.xml、beans.xml
2.2.测试
/**
* 模拟表现层
*/
public class client {
public static void main(string[] args) {
//1.使用applicationcontext接口，就是在获取spring容器
applicationcontext ac = new
classpathxmlapplicationcontext("applicationcontext.xml");
//2.根据bean的id获取对象
userdao userdao = (userdao) ac.getbean("userdao");
system.out.println(userdao);
userservice userservice = (userservice) ac.getbean("userservice");
system.out.println(userservice);
userservice.adduser();
}
}3.di
概述：di（dependency injection）依赖注入，在spring创建对象的同时，为其属性赋值，称之为依赖注入。
3.1.构造函数注入
顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让spring框架来为我们注入。具体代码如下：
/**
* 业务层实现类
*/
public class userserviceimpl implements userservice {
private userdao userdao;
private string name;
private integer age;
public userserviceimpl(userdao userdao, string name, integer age) {
this.userdao = userdao;
this.name = name;
this.age = age;
}
public void adduser(){
system.out.println(name+","+age);
userdao.adduser();
}
}<?xml version="1.0" encoding="utf-8"?>
<!--1、注意：要导入schema约束-->
<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">
<!--2、把对象交给spring来创建-->
<bean id="userdao" class="com.by.dao.userdaoimpl"></bean>
<bean id="userservice" class="com.by.service.userserviceimpl">
<!--
要求：类中需要提供一个对应参数列表的构造函数。
标签：constructor-arg
==给谁赋值:==
index:指定参数在构造函数参数列表的索引位置
name:指定参数在构造函数中的名称
==赋什么值:==
value:它能赋的值是基本数据类型和string类型
ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
-->
<constructor-arg name="userdao" ref="userdao"></constructor-arg>
<constructor-arg name="name" value="张三"></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
</bean>
</beans>3.2.set方法注入
顾名思义，就是在类中提供需要注入成员的set方法。具体代码如下：
/**
* 业务层实现类
*/
public class userserviceimpl implements userservice {
private userdao userdao;
private string name;
private integer age;
public void setuserdao(userdao userdao) {
this.userdao = userdao;
}
public void setname(string name) {
this.name = name;
}
public void setage(integer age) {
this.age = age;
}
public void adduser(){
system.out.println(name+","+age);
userdao.adduser();
}
}<?xml version="1.0" encoding="utf-8"?>
<!--1、注意：要导入schema约束-->
<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">
<!--2、把对象交给spring来创建-->
<bean id="userdao" class="com.by.dao.userdaoimpl"></bean>
<bean id="userservice" class="com.by.service.userserviceimpl">
<!--
要求：property
标签：constructor-arg
==给谁赋值:==
name:找的是类中set方法后面的部分
==赋什么值:==
value:它能赋的值是基本数据类型和string类型
ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
-->
<property name="userdao" ref="userdao"></property>
<property name="name" value="张三"></property>
<property name="age" value="18"></property>
</bean>
</beans>3.3.自动注入
不用在配置中 指定为哪个属性赋值，由spring自动根据某个 "原则" ，在工厂中查找一个bean并为属性注入值。具体代码如下：
/**
* 业务层实现类
*/
public class userserviceimpl implements userservice {
private userdao userdao;
public void setuserdao(userdao userdao) {
this.userdao = userdao;
}
public void adduser(){
userdao.adduser();
}
}<?xml version="1.0" encoding="utf-8"?>
<!--1、注意：要导入schema约束-->
<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">
<!--2、把对象交给spring来创建-->
<bean id="userdao" class="com.by.dao.userdaoimpl"></bean>
<!--autowire="bytype"：按照类型自动注入值-->
<bean id="userservice" class="com.by.service.userserviceimpl" autowire="bytype">
</bean>
</beans><?xml version="1.0" encoding="utf-8"?>
<!--1、注意：要导入schema约束-->
<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">
<!--2、把对象交给spring来创建-->
<bean id="userdao" class="com.by.dao.userdaoimpl"></bean>
<!--autowire="bytype"：按照类型自动注入值-->
<bean id="userservice" class="com.by.service.userserviceimpl" autowire="byname">
</bean>
</beans>3.4.注入集合类型的属性
顾名思义，就是给类中的集合成员传值，它用的也是set方法注入的方式，只不过变量的数据类型都是集合。我们这里介绍注入数组，list,set,map。具体代码如下：
/**
* 业务层实现类
*/
public class userserviceimpl implements userservice {
private userdao userdao;
private string[] mystrs;
private list<string> mylist;
private set<string> myset;
private map<string,string> mymap;
public void setuserdao(userdao userdao) {
this.userdao = userdao;
}
public void setmystrs(string[] mystrs) {
this.mystrs = mystrs;
}
public void setmylist(list<string> mylist) {
this.mylist = mylist;
}
public void setmyset(set<string> myset) {
this.myset = myset;
}
public void setmymap(map<string, string> mymap) {
this.mymap = mymap;
}
public void adduser(){
system.out.println(arrays.tostring(mystrs));
system.out.println(mylist);
system.out.println(myset);
system.out.println(mymap);
userdao.adduser();
}
}<?xml version="1.0" encoding="utf-8"?>
<!--1、注意：要导入schema约束-->
<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">
<!--2、把对象交给spring来创建-->
<bean id="userdao" class="com.by.dao.userdaoimpl"></bean>
<bean id="userservice" class="com.by.service.userserviceimpl">
<!--
要求：property
标签：constructor-arg
==给谁赋值:==
name:找的是类中set方法后面的部分
==赋什么值:==
value:它能赋的值是基本数据类型和string类型
ref:它能赋的值是其他bean类型，也就是说，必须得是在配置文件中配置过的bean
-->
<property name="userdao" ref="userdao"></property>
<!-- 给myset集合注入数据 -->
<property name="myset">
<set>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</set>
</property>
<!-- 注入array数组数据 -->
<property name="myarray">
<array>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</array>
</property>
<!-- 注入list集合数据 -->
<property name="mylist">
<list>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</list>
</property>
<!-- 注入map数据 -->
<property name="mymap">
<map>
<entry key="testa" value="aaa"></entry>
<entry key="testb" value="bbb"></entry>
</map>
</property>
</bean>
</beans>到此这篇关于spring的ioc解决程序耦合的实现的文章就介绍到这了,更多相关spring ioc程序耦合内容请搜索代码网以前的文章或继续浏览下面的相关文章希望大家以后多多支持代码网！
发表评论