因为是个人复习java的总结,所以结构稍显杂乱,有些语句过于口语化.
其实就是一个分层的框架,主要就是Ioc反转控制技术和Aop面向切面编程两个内核技术.然后提供了像Spring MVC面向表现层的技术和Spring JDBC面向持久层的技术
在了解Ioc控制反转之前,需要了解为什么要时使用Ioc以及Ioc的作用.
Ioc其实主要就是用来削减代码的耦合性,那么什么叫做代码的耦合性,那就是代码和代码之间的关联性太强,关联性太强就会导致代码不易进行修改或者是更改配置.如果之前有看过我使用Servlet写个人网页的时候的思考,就会知道这个问题之前一直也困扰着我.像表现层和业务层,业务层和持久层.这些之间的联系太过紧密,因为之前都是直接通过在上一个层面创建下一个层面的实例,然后调用方法的.这就注定了两者之间形成了不可或缺的关系.
如果自行解耦的话,一般就是像持久层中对于数据库连接解耦的操作一样.通过一个类去读取配置文件,然后使用反射返回需要的对象.这样做就能减少两者之间的依赖关系,之后如果想要修改,完全可以修改配置的信息,使上层调用不同的下层对象,从而达到不同的功能.
当然这里具体的实现,当然可以采用工厂模式,因为最终目的是生成一个下层的对象,但是又期望能够减少上下之间的关联.
但是需要注意,这里做到的只是减少关联,完全消除关联是不存在的,两者不存在关联,那么就是独立的两个,根本不需要考虑两者之间的关系.
这里其实主要的就是创建服务层和持久层对象的工厂类,但是没必要细究整体的思路,感受一下解耦上的思路,其实写着有一点偏题,变到设计模式去了.之后会再研究Spring的源码.
工厂类
我要评论public class BeanFactory {
//创建Propertis流对象,其实这里可以采用xml的解析方式配置,但是自己实现简单一点,感受一下,使用了properties
private static Properties properties;
//单例,初始化存放所有的对象,有一点点浪费
private static Map<String,Object> beans;
static {
properties = new Properties();
InputStream in = BeanFactory.class.getClassLoader().getSystemResourceAsStream("bean.properties");
try {
properties.load(in);
} catch (IOException e) {
throw new ExceptionInInitializerError("Bean.properties初始化失败");
}
beans = new HashMap<String, Object>();
Set<Object> keys = properties.keySet();
for (Object key : keys){
String k = key.toString();
Object v = null;
try {
v = Class.forName(properties.getProperty(k)).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
beans.put(k,v);
}
}
//修改之后获取的是同一个资源,但是这种实现方式还是存在问题,应该还可以再解耦
public static Object getBean(String accountDao) {
return beans.get(accountDao);
}
// //修改之前的获取实例的方法,会产生多例
// public static Object getBean(String accountDao) {
// String beanPath = properties.getProperty(accountDao);
// Object bean = null;
// try {
// bean = Class.forName(beanPath).newInstance();
// } catch (ClassNotFoundException e) {
// e.printStackTrace();
// } catch (IllegalAccessException e) {
// e.printStackTrace();
// } catch (InstantiationException e) {
// e.printStackTrace();
// }
// return bean;
// }
}
表现层
public class Client {
public static void main(String[] args) {
//这里就是模拟多线程访问服务层,如果不对工厂设置单例,那么这里就会形成多例对象,调用的资源也各自独立
//但是使用工厂模式,那配合上单例资源是很常见的情况,那么这时候就需要对工厂类进行一些补充
for(int i=0; i<5; i++){
AccountService service = (AccountService) BeanFactory.getBean("accountService");
System.out.println(service);
service.saveAccount();
}
}
}
服务层
public class AccountServiceImpl implements AccountService {
// //之前采用的就是这种方式,直接在业务层创建持久层的对象,然后调用方法.
// private AccountDao dao = new AccountDaoImpl();
private AccountDao dao = (AccountDao) BeanFactory.getBean("accountDao");
private int i=0;
public void saveAccount() {
dao.saveAccount();
System.out.println(i);
i++;
}
}
bean.properties
accountService=cjlu.cct.survice.impl.AccountServiceImpl
accountDao=cjlu.cct.dao.impl.AccountDaoImpl
上面总的来说其实就是理解Ioc控制反转,将控制具体对象创建的权力从上层的移到了工厂或者是框架,而工厂通过配置和反射将设置暴露给外部.从而实现了上层和下层的解耦.
其实使用跟之前Mybatis差不多,首先就是需要使用maven配置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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="accountDao" class="cjlu.cct.dao.impl.AccountDaoImpl"></bean>
<bean id="accountService" class="cjlu.cct.survice.impl.AccountServiceImpl"></bean>
</beans>
上面主要配置了方法层和持久层的对象和id的对应关系,为什么这样写,其实spring的思路和上面我们提到的使用mapper初始化所有需要使用到的资源的思路差不多.这里就是设置对应关系,然后就是读取配置文件信息,然后获取对应的对象,比如说下面:
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
AccountService accountService = (AccountService) applicationContext.getBean("accountService");
AccountDao accountDao = applicationContext.getBean("accountDao",AccountDao.class);
其实从上面的使用来看，最主要的就是ApplicationContext这个用来获取对象的容器。其实Spring Ioc还有一种容器BeanFactory。
区别一下这两个容器，前者是之后开发主要使用的容器，其实前者是后者的一个子类，具有更加完善的功能，默认情况下在加载容器的时候就创建了配置的资源对象。
后者其实是Spring框架内部使用的一种容器，在使用对象的时候才会去初始化对象资源。
虽然看起来前者的方式会浪费一些资源，但是从整体上来说，在用户使用资源前创建好资源，而不是在使用的时候去临时消耗时间创建，更加符合用户的需求。
首先这个接口的整体继承结构是这样的,可以看出其顶层为三个就很像我们之前的思路,读取配置文件,通过工厂进行创建对象,然后还有一个功能的注解,目前还不明确是什么用的.
现在主要的问题是对于ApplicationContext的使用,明显我们不能直接使用这个接口,应该使用其实现类.有一点需要先明确,这个类使用来加载配置根据id获取对象的核心容器,所以其实现类应该是不同的读取配置方式生成对象,其实现类常用的为三种:
了解完容器之后，需要着重了解的肯定是对于容器中创建的Bean对象的管理问题。
<bean id="accountDao" class="cjlu.cct.dao.impl.AccountDaoImpl"></bean>
<bean id="accountDaoFactory" class="cjlu.cct.factory.AccountDaoFactory"></bean>
<bean id="accountDao" factory-bean="accountDaoFactory" factory-method="getAccountDao"></bean>
<bean id="accountDao" class="cjlu.cct.factory.AccountDaoFactory" factory-method="getAccountDao"></bean>
其实总结来说，就是在xml中使用<bean>标签并且添加属性，从而配置Bean对象的创建。
其实之前我们自己考虑解耦的时候也考虑到Ioc方式获取的对象不应该每次都创建新的,当时是通过map来初始化了所有对象,从而保证单例.但是这样做明显过于简单的.Spring中对这部分进行了考虑,表现形式就是Bean对象的作用域,在哪个范围内的对象会使得共享同一个对象资源.
使用需要修改<bean>中的scope属性,主要取值如下:
singleton
单例的模式,也是默认模式,对所有范围都是单例的
prototype
多例的模式,每次都会创建新的对象
request
看到这个,很容易联想到就是相对于web中的request域,一次请求会保证相同的对象资源
session
对应于web中的session,一次会话范围的对象资源
global-session
针对的是集群环境下的会话,但是集群环境之前都还没有接触到过.其实就是针对多台物理设备运行同一个服务的时候,当多次访问这个服务的时候,很可能出现访问的不是同一个物理设备,那就存在前面存储session的数据却读不出来的额问题,global-session就是解决这个问题,实际上一般都是通过额外的物理设备去存储数据,使用软件实现不太实惠.这个问题有一个名称就做负载均衡.
单例的时候,创建的对象随容器而初始化,随容器销毁而销毁.其实比较好理解,这里就像是之前自己写的简单案例一样,在创建容器的时候初始化对象,那么这个对象因为被容器引用着,所以一直存在,但是随着容器销毁,对象也会销毁.
多例的时候,这时候就不一样,是随着对象被调用到的时候创建对象,而销毁对象是在对象长时间不使用销毁.也就是被垃圾回收机制给回收.
其实就是针对上面通过Ioc管理对象的时候，对象肯定不可能都是单纯的没有依赖的对象。如果管理存在依赖的对象的时候，不可能全都有无参的构造器去调用。那么就需要依赖注入来实现管理的对象的依赖的注入。或者说是给对象注入依赖属性。
依赖注入一般分为两种方式注入：
<bean>中添加<property>进行属性的注入。例子如下：<bean id="person" class="cjlu.cct.domain.Person">
<property name="name" value="tom"></property>
</bean>
<bean>中添加<constructor-arg>标签，这样就会根据配置的构造器传入参数注入属性。如下：<bean>
<constructor-arg name="name" value="tom"></constructor-arg>
<constructor-arg name="address" value="home"></constructor-arg>
</bean>
其实就是使用p名称空间去简化地配置属性，概念和c中地内容有点像。使用的时候首先需要再限制头中添加p空间的限制
xmlns:p="http://www.springframework.org/schema/p"
然后就可以直接再<bean>的配置中，使用p属性，来添加属性注入。实例如下：
<bean id="person" class="cjlu.cct.domain.Person" p:name="tom"
p:address="home"></bean>
其实上面的内容，存在一些问题，就是目前涉及到的都是能够直接传入的数据，但是注入的属性中肯定会涉及到集合，具有依赖的对象。
其实这就是我们上面使用到的注入属性，这里需要注意两个点：
<null/>标签，嵌套在<property>中实现。<property name="name">
<value><![CDATA[ 带有特殊符号的内容 ]]></value>
</property>
其实就是基于<bean>标签是用来创建控制的对象的，那么如果在这个对象中的属性存在依赖其他对象的时候。那么肯定也需要创建外部的对象注入当前对象。
如果注入的对象是当前Bean外部创建的对象，就是外部Bean对象注入。简单点说就是在xml的配置中表现为两个相同级别的<bean>，在其中一个<bean>引用到了另外一个<bean>，实例如下：
<bean id="personService" class="cjlu.cct.service.PersonService">
<property name="personDao" ref="personDaoImpl"></property>
</bean>
<bean id="personDaoImpl" class="cjlu.cct.dao.impl.PersonDaoImpl"></bean>
就是创建了持久层的对象，而在服务层创建对象的时候使用到了这个持久层对象。因为持久层对象不是在服务层对象内部创建的，所以是注入外部Bean对象。
其实相当于外部Bean对象，在<bean>标签中创建的<bean>对象，其实本质上和外部Bean区别不大，只是内部Bean不用写id，因为是服务于某个对象的对象。
区别一下外部Bean，外部Bean是可以被重复调用查找到的，因为相当于是创建的一个资源。
级联方式，其实本质上是基于外部Bean注入，就是先设置一个属性为外部对象引用，再设置这个属性对象中的具体属性。概念说着复杂，实例很好理解：
<bean id="emp" class="cjlu.cct.domain.Emp">
<property name="name" value="jack"></property>
<property name="dept" ref="dept"></property>
<property name="dept.name" value="sale"></property>
</bean>
<bean id="dept" class="cjlu.cct.domain.Dept">
<property name="name" value="technology"></property>
</bean>
感觉实际操作中意义不大。而且需要注意一点，使用级联的时候，对于下面那条设置具体属性的配置需要在实体类中存在getter方法的情况下使用。其实也好理解，不获取怎么判断赋值。
其实很简单，主要就是几类集合，数组，list，map，set。首先当然需要在实体类中设置。
然后配置中主要使用一下几个标签<array>,<list>,<map>,<set>配套<value>或者<entry>标签配置。具体例子如下：
<properties name="maps">
<map>
<entry key="" value=""></entry>
</map>
</properties>
<properties name="maps">
<list>
<value>需要设置的内容</value>
</list>
</properties>
写两个差不多，配置没有什么大的区别，但是对于需要注入对象的属性，存在一点区别，就是使用的是标签作为参数。
但是上面这种方式其实非常繁琐，需要创建很多外部对象，然后还要一个个传到对应的对象中去。有一种简化方式，使用util命名空间
首先需要添加限制头
xmlns:util="http://www.springframework.org/schema/util"
另外需要修改
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/uitl
http://www.springframework.org/schema/uitl/spring-uitl.xsd">
其实util相当于是能够帮助管理多个需要注入的属性形成一个类似集合的存在，从而对应需要注入属性中的集合。主要是增加了代码的复用。实例如下：
<util:list id="bookList">
<ref bean=""></ref>
<value>需要设置的内容</value>
</util:list>
<bean>
<property name="list" ref="bookList"></property>
</bean>
如有错误欢迎读者批评指正!!
本文地址：https://blog.csdn.net/weixin_43913376/article/details/107370202
如对本文有疑问， 点击进行留言回复！！
![[杭电多校2020]第一场 1004 Distinct Sub-palindromes](http://www.lhsxpumps.com/_images5/10qianwan/20200724/s_0_202007241733388592.png)
[杭电多校2020]第一场 1004 Distinct Sub-palindromes
Swift -- 将本地生成的UIImage进行持久化保存（存到文件中fileManager.createFile）
网友评论