spring(1)
一、耦合
1. 定义
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。在软件工程中，耦合指的就是就是对象之间的依赖性。对象之间的耦合越高，维护成本越高。因此对象的设计应使类和构件之间的耦合最小。软件设计中通常用耦合度和内聚度作为衡量模块独立程度的标准。 划分模块的一个准 则就是高内聚低耦合。
2. 分类
(1) 内容耦合
当一个模块直接修改或操作另一个模块的数据时，或一个模块不通过正常入口而转入另一个模块时，这样的耦合被称为内容耦合。内容耦合是最高程度的耦合，应该避免使用之。
(2) 公共耦合
两个或两个以上的模块共同引用一个全局数据项，这种耦合被称为公共耦合。在具有大量公共耦合的结构中，确定究竟是哪个模块给全局变量赋了一个特定的值是十分困难的。
(3) 外部耦合
一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。
(4) 控制耦合
一个模块通过接口向另一个模块传递一个控制信号，接受信号的模块根据信号值而进行适当的动作，这种耦合被称为控制耦合。
(5) 标记耦合
若一个模块 A 通过接口向两个模块 B 和 C 传递一个公共参数，那么称模块 B 和 C 之间存在一个标记耦合。
(6) 数据耦合
模块之间通过参数来传递数据，那么被称为数据耦合。数据耦合是最低的一种耦合形式，系统中一般都存在这种类型的耦合，因为为了完成一些有意义的功能，往往需要将某些模块的输出数据作为另一些模块的输入数据。
(7) 非直接耦合
两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。
3. 总结：
耦合是影响软件复杂程度和设计质量的一个重要因素，在设计上我们应采用以下原则：如果模块间必须存在耦合，就尽量使用数据耦合，少用控制耦合，限制公共耦合的范围，尽量避免使用内容耦合。
4. 内聚与耦合
内聚标志一个模块内各个元素彼此结合的紧密程度，它是信息隐蔽和局部化概念的自然扩展。内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。
耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。 程序讲究的是低耦合，高内聚。就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却要不那么紧密。
内聚和耦合是密切相关的，同其他模块存在高耦合的模块意味着低内聚，而高内聚的模块意味着该模块同其他模块之间是低耦合。在进行软件设计时，应力争做到高内聚，低耦合。
二、解决耦合（解耦）的思路
1. 编译期依赖
例如在代码中某个类直接调用了另一个类，那么就产生了编译期依赖，如果被依赖的类遗失，那么编译都无法通过。
2. 运行时依赖
在一个类调用其他类的时候，我们采用反射来调用类名，那么在代码中只存在被依赖类的全限定类名的字符串，即使被依赖类遗失，那么编译也是可以通过的。
3. 工厂模式
隐藏对象建立的细节，向工厂传递对象的名称即可拿到对象，下面是示例：
public class ShapeFactory {
//使用 getShape 方法获取形状类型的对象
public Shape getShape(String shapeType){
if(shapeType == null){
return null;
}
if(shapeType.equalsIgnoreCase("CIRCLE")){
return new Circle();
} else if(shapeType.equalsIgnoreCase("RECTANGLE")){
return new Rectangle();
} else if(shapeType.equalsIgnoreCase("SQUARE")){
return new Square();
}
return null;
}
}
4. 使用工厂模式进行解耦
我们知道一般代码有service层、dao层、以及ui层（例如servlet），那么在原先的情况下，我们在service层中会调用dao，在ui层中调用service，那么我们必须在service层和ui层中创建相应的对象。这就产生了依赖。
dao层
public daoImpl{
public void save Account(){
//保存账户代码，省略...
}
}
service层
public serviceImpl{
--priviate static daoimpl=new daoImpl();--
public void register(){
daoimpl.saveAccount();
}
}
ui层
public uiClient{
--priviate static serviceimpl=new serviceImpl();--
public void registerClick(){
serviceimpl.register();
}
}
上述代码中标星号的代码就是耦合部分。
在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并--存起来--。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂。下面代码就是工厂模式的基本应用了。
配置文件：config.xml
key:value形式
key是唯一限定名指代每个类，value记录每个类的全限定类名
daoImpl:dao.daoimpl.daoImpl
serviceImpl:service.serviceimpl.serviceImpl
dao层
public daoImpl{
public void save Account(){
//保存账户代码，省略...
}
}
service层
public serviceImpl{
--priviate static daoimpl=beanFactory.getBean("daoImpl");--
public void register(){
daoimpl.saveAccount();
}
}
ui层
public uiClient{
--priviate static daoimpl=beanFactory.getBean("serviceImpl");--
public void registerClick(){
serviceimpl.register();
}
}
/--
- 一个创建Bean对象的工厂
-
- Bean：在计算机英语中，有可重用组件的含义。
- JavaBean：用java语言编写的可重用组件。
- javabean > 实体类
-
- 它就是创建我们的service和dao对象的。
-
- 第一个：需要一个配置文件来配置我们的service和dao
- 配置的内容：唯一标识=全限定类名（key=value)
- 第二个：通过读取配置文件中配置的内容，反射创建对象
-
- 我的配置文件可以是xml也可以是properties
-/
public class BeanFactory {
//定义一个Properties对象
private static Properties props;
//定义一个Map,用于存放我们要创建的对象。我们把它称之为容器
private static Map<String,Object> beans;
//使用静态代码块为Properties对象赋值
static {
try {
//实例化对象
props = new Properties();
//获取properties文件的流对象
InputStream in = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
props.load(in);
//实例化容器
beans = new HashMap<String,Object>();
//取出配置文件中所有的Key
Enumeration keys = props.keys();
//遍历枚举
while (keys.hasMoreElements()){
//取出每个Key
String key = keys.nextElement().toString();
//根据key获取value
String beanPath = props.getProperty(key);
//反射创建对象
Object value = Class.forName(beanPath).newInstance();
//把key和value存入容器中
beans.put(key,value);
}
}catch(Exception e){
throw new ExceptionInInitializerError("初始化properties失败！");
}
}
/--
- 根据bean的名称获取对象
- @param beanName
- @return
-/
public static Object getBean(String beanName){
return beans.get(beanName);
}
/--
- 根据Bean的名称获取bean对象
- @param beanName
- @return
-/
public static Object getBean2(String beanName){
Object bean = null;
try {
String beanPath = props.getProperty(beanName);
bean = Class.forName(beanPath).newInstance();//每次都会调用默认构造函数创建对象
}catch (Exception e){
e.printStackTrace();
}
return bean;
}
}
关于--存起来--
在上述代码中有个getBean2()方法中，调用该方法每次都会生成一个新的对象，那么就是--多例情况--；而调用getBean()方法则是从已经在static代码块中生成并保存在Map容器取出，这是--单例情况--。单例对象效率更高，而且由于我们几乎不会定义成员变量，所以也几乎没有线程问题。
三、Spring Ioc
1. Ioc
inversion of control，控制反转。将依赖对象的控制权交给spring Ioc容器，即为控制反转（控制权的转移）。在前面我们需要自己编写factory工厂类以及配置文件，但使用了spring框架后，我们只需要编写配置文件，剩下的交给spring来做就好。
2. 基于xml的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">
</beans>
3.beanFactory和ApplicationContext
beanFactory是spring框架中的顶层接口，ApplicationContext 是它的子接口。
(1) BeanFactory 和 ApplicationContext 的区别：创建对象的时间点不一样。
ApplicationContext：只要一读取配置文件，默认情况下就会创建对象。
BeanFactory：什么使用什么时候创建对象。
(2) ApplicationContext三种实现类
ClassPathXmlApplicationContext
它是从类的根路径下加载配置文件 推荐使用这种。
FileSystemXmlApplicationContext
它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置（要有系统权限）。
AnnotationConfigApplicationContext
当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
4. spring Ioc中bean标签和管理对象细节
(1) bean标签
作用：
用于配置对象让 spring 来创建的。
默认情况下它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
属性：
id：给对象在容器中提供一个唯一标识。用于获取对象。
class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
scope：指定对象的作用范围。
- singleton :默认值，单例的.
- prototype :多例的.
- request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中.
- session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到session 域中.
- global session :WEB 项目中,应用在 Portlet 环境.如果没有 Portlet 环境那么globalSession 相当于 session.
- init-method：指定类中的初始化方法名称。
- destroy-method：指定类中销毁方法名称。
(2) bean 的作用范围和生命周期
单例对象：scope="singleton"
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
与容器相同。
多例对象：scope="prototype"
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。
(3) 实例化 Bean 的三种方式
第一种方式：使用默认无参构造函数。在默认情况下，它会根据默认无参构造函数来创建类对象。如果 bean 中没有默认无参构造函数，将会创建失败。
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"/>
第二种方式：spring 管理静态工厂- 使用静态工厂的方法创建对象。即用某个类的静态方法返回值对象存入容器。
//模拟一个静态工厂，创建业务层实现类
public class StaticFactory {
public static IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是:
使用 StaticFactory 类中的静态方法 createAccountService 创建对象，并存入 spring 容器
id 属性：指定 bean 的 id，用于从容器中获取
class 属性：指定静态工厂的全限定类名
factory-method 属性：指定生产对象的静态方法
-->
<bean id="accountService"
class="com.itheima.factory.StaticFactory"
factory-method="createAccountService"></bean>
第三种方式：spring 管理实例工厂- 使用实例工厂的方法创建对象。即用某个类中实例方法的返回值对象存入容器。
/**
* 模拟一个实例工厂，创建业务层实现类
* 此工厂创建对象，必须现有工厂实例对象，再调用方法
*/
public class InstanceFactory {
public IAccountService createAccountService(){
return new AccountServiceImpl();
}
}
<!-- 此种方式是：
先把工厂的创建交给 spring 来管理。
然后在使用工厂的 bean 来调用里面的方法
factory-bean 属性：用于指定实例工厂 bean 的 id。
factory-method 属性：用于指定实例工厂中创建对象的方法。
-->
<bean id="instancFactory" class="com.itheima.factory.InstanceFactory"></bean>
<bean id="accountService"
factory-bean="instancFactory"
factory-method="createAccountService"></bean>
四、 spring DI 依赖注入
1. 定义：依赖注入是Ioc思想的一种实现方法，Ioc是一种解决问题的思想，而DI就是该思想的实际化解决问题的方法。
(1) 依赖注入的定义：依赖关系的维护。
依赖注入：Dependency Injection。它是 spring 框架核心 ioc 的具体实现。
我们的程序在编写时，通过控制反转，把对象的创建交给了 spring，但是代码中不可能出现没有依赖的情况。
ioc 解耦只是降低他们的依赖关系，但不会消除。例如：我们的业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 spring 之后，就让 spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。
2.能够注入的数据
(1) 基本类型和string
(2) 其他bean类型（在配置文件中或者注解配置过的bean）
(3) 复杂集合类型
3. 依赖注入的两种方式
(1) 构造函数
顾名思义，就是使用类中的构造函数，给成员变量赋值。注意，赋值的操作不是我们自己做的，而是通过配置的方式，让 spring 框架来为我们注入。具体代码如下：
public class AccountServiceImpl implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public AccountServiceImpl(String name, Integer age, Date birthday) {
this.name = name;
this.age = age;
this.birthday = birthday;
}
@Override
public void saveAccount() {
System.out.println(name+","+age+","+birthday);
}
}
<!-- 使用构造函数的方式，给 service 中的属性传值
要求：
类中需要提供一个对应参数列表的构造函数。
涉及的标签：
constructor-arg
属性：
index:指定参数在构造函数参数列表的索引位置
type:指定参数在构造函数中的数据类型
name:指定参数在构造函数中的名称 用这个找给谁赋值
=======上面三个都是找给谁赋值，下面两个指的是赋什么值的==============
value:它能赋的值是基本数据类型和 String 类型
ref:它能赋的值是其他 bean 类型，也就是说，必须得是在配置文件中配置过的 bean
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<constructor-arg name="name" value=" 张三 "></constructor-arg>
<constructor-arg name="age" value="18"></constructor-arg>
<constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>
<bean id="now" class="java.util.Date"></bean>
(2) set方法注入
顾名思义，就是在类中提供需要注入成员的 set 方法。具体代码如下：
public class AccountServiceImpl implements IAccountService {
private String name;
private Integer age;
private Date birthday;
public void setName(String name) {
this.name = name;
}
public void setAge(Integer age) {
this.age = age;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
@Override
public void saveAccount() {
System.out.println(name+","+age+","+birthday);
}
}
<!-- 通过配置文件给 bean 中的属性传值：使用 set 方法的方式
涉及的标签：
property
属性：
name：找的是类中 set 方法后面的部分
ref：给属性赋值是其他 bean 类型的
value：给属性赋值是基本数据类型和 string 类型的
实际开发中，此种方式用的较多。
-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
<property name="name" value="test"></property>
<property name="age" value="21"></property>
<property name="birthday" ref="now"></property>
</bean>
<bean id="now" class="java.util.Date"></bean>
(3) 使用set注入复杂的数据类型
<!--
复杂类型的注入/集合类型的注入
用于给List结构集合注入的标签
list array set
用于给Map结构集合注入的标签
map props
结构相同，标签可以互换
-->
<bean id="accountService3" class="com.li.service.impl.AccountServiceImpl3">
<property name="myStrs">
<array>
<value>aaa</value>
<value>bbb</value>
<value>ccc</value>
</array>
</property>
<property name="myList">
<list>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</list>
</property>
<property name="mySet">
<set>
<value>AAA</value>
<value>BBB</value>
<value>CCC</value>
</set>
</property>
<property name="myMap">
<map>
<entry key="testA" value="aaa"></entry>
<entry key="testB" value="bbb"></entry>
</map>
</property>
<property name="myProp">
<props>
<prop key="testC">ccc</prop>
<prop key="testD">ddd</prop>
</props>
</property>
</bean>
public class AccountServiceImpl3 implements IAccountService {
private String[] myStrs;
private List<String> myList;
private Set<String> mySet;
private Map<String,String> myMap;
private Properties myProp;
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 setMyProp(Properties myProp) {
this.myProp = myProp;
}
public void saveAccount() {
System.out.println(Arrays.toString(myStrs));
System.out.println(myList);
System.out.println(mySet);
System.out.println(myMap);
System.out.println(myProp);
}
浙公网安备 33010602011771号