江西车祸,王若林,可爱颂歌词谐音歌词
程序的耦合和解耦。
1、问题引入。
在使用jdbc和数据库交互时。注册驱动：drivermanager.registerdriver(new com.mysql.cj.jdbc.driver());
如果把mysql的依赖（jar包）删掉，那么程序在编译期就会出现错误。也就是说当前类，依赖于driver类。
2、程序的耦合。
耦合：简单来说，就是程序间的依赖关系。包括：类之间的依赖、方法之间的依赖。
解耦：降低程序间的依赖关系。
实际开发中应做到：编译期不依赖，运行时才依赖。
之前注册驱动时，一直用的是 class.forname("com.mysql.cj.jdbc.driver")。它依赖的只是一个字符串。
所以，
解耦的思路：
* 第一步：使用反射来创建对象，而 避免使用new关键字。
问题：这样的话，字符串写死了，如果以后用其他数据库驱动，需要改源码。
* 第二部：通过读取配置文件来获取要创建的对象全类名。
3、另一个问题。
通过分析，在之前的三层架构中，各个层之间的调用也有很大的耦合问题。
解决方案：工厂模式解耦。
创建一个 创建bean对象的工厂。
bean：代表可重用组件的含义。
javabean：用java编写的可重用组件。javabean > 实体类。
第一：需要一个配置文件来配置service和dao。配置的内容：唯一标识=全类名。
第二：通过读取配置文件的内容，反射创建对象。
我要评论public class beanfactory {
private static properties properties;
static {
properties=new properties();
inputstream is=beanfactory.class.getclassloader().getresourceasstream("beanfactory.properties");
try {
properties.load(is);
} catch (ioexception e) {
e.printstacktrace();
}
}
public static object getbean(string beanname) {
object bean=null;
string beanpath=properties.getproperty(beanname);
try {
bean=class.forname(beanpath).newinstance();
} catch (instantiationexception e) {
e.printstacktrace();
} catch (illegalaccessexception e) {
e.printstacktrace();
} catch (classnotfoundexception e) {
e.printstacktrace();
}
return bean;
}
}
由于这句代码的存在 bean=class.forname(beanpath).newinstance(); 导致每次用的时候都会创建一个新的对象。
改进方法：将对象先创建完，存入集合中，用的时候直接在集合中拿。、
改进后的工厂模式：
public class beanfactory {
private static properties properties;
private static map<string,object> beans;
static {
properties=new properties();
inputstream is=beanfactory.class.getclassloader().getresourceasstream("beanfactory.properties");
try {
properties.load(is);
beans =new hashmap<string, object>();
enumeration keys = properties.keys();
while (keys.hasmoreelements()){
string key=keys.nextelement().tostring();
string beanpath=properties.get(key).tostring();
object value=class.forname(beanpath).newinstance();
beans.put(key,value);
}
} catch (exception e) {
e.printstacktrace();
}
}
public static object getbean(string beanname) {
return beans.get(beanname);
}
}
private acountdao dao=new acountdaoimp();
private acountdao dao=(acountdaoimp)beanfactory.getbean("acountdao");
这两种获取对象的形式上，第一种，应用程序直接依赖于资源。而第二种，利用工厂消除了应用程序和资源的直接依赖关系。
第二种方法的思想，就是ioc。
为什么叫控制反转，不叫降低依赖？
因为，对于应用程序来说，用第一种方式创建对象时，有自己的独立控制权，想要谁就要谁，而第二种方式，应用程序失去了控制器，把控制权交给了工厂和配置文件。这种控制权发生的转移，就是控制反转。
spring的ioc和di。
控制反转（inversion of control，ioc）把创建对象的权力交给框架，是框架的重要特征。
ioc的作用：削减计算机程序的耦合。
spring基于xml的ioc的环境搭建：
1、导入依赖。
2、配置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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="acountdao" class="acountdao.acountdaoimp"></bean>
<bean id="acountservice" class="acountservice.acountserviceimp"></bean>
</beans>
3、主程序。
public static void main(string[] args) {
//1、获取核心容器对象
applicationcontext ac=new classpathxmlapplicationcontext("bean.xml");
//2、根据id获取bean对象
acountservice acountservice=(acountservice)ac.getbean("acountservice");
acountdao acountdao=ac.getbean("acountdao",acountdao.class);
system.out.println(acountservice);
system.out.println(acountdao);
}
applicationcontext 的三个常用实现类。
1、classpathxmlapplicationcontext:它可以加载类路径下的配置文件，要求配置文件必须在类路径下。
2、filesystemxmlapplicationcontext：它可以加载任意路径下的配置文件。
3、annotationconfigapplicationcontext：用于注解创建容器。
核心容器的两个接口。
1、applicationcontext：它在构建核心容器时，创建对象采用的策略是立即加载的方式，也就是说，只要一读取完配置文件，马上就创建对象。
2、beanfactory：它采用延迟加载的方式，什么时候需要，什么时候创建对象。
spring对bean的管理细节。
1、创建bean 的三种方式。
* 使用默认构造函数创建：在spring配置文件中使用bean标签，配以id和class属性，且没有其他属性和标签时，采用的就是默认构造函数创建bean对象，此时如果类中没有默认构造函数，则无法创建。
* 使用普通工厂的方法创建对象（使用某个类的方法创建其他类对象）：在bean标签中使用 factory-bean和factory-method 属性指定类和方法。
* 使用工厂的静态方法创建对象（使用某个类的静态方法创建对象）：使用class和factory-method属性。
2、bean的作用范围。
bean标签的scope属性取值：
* singleton：单例的（默认值） 常用
* prototype：多例的。常用
* request：作用于web应用的请求范围。
* session：作用于web应用的会话范围。
* global-session：作用于集群环境的会话范围。
3、bean对象的生命周期。
* 单例对象。
出生：当容器创建时对象出生。
活着：只要容器存在，对象就一直存在。
死亡：容器销毁，对象销毁。
总结：单例对象的生命周期和容器相同。
* 多例对象。
出生：要使用对象时创建。
活着：对象 只要在使用过程中就一直活着。
死亡：对象长时间不用，且没有被引用时，由jvm回收。
spring中的依赖注入。
ioc的作用：降低程序间的依赖关系（耦合）
依赖关系的管理：以后都交给spring来维护。
在当前类需要用到其他类的对象时，由spring为我们提供，我们只需在配置文件中说明。
依赖关系的维护就称之为依赖注入。
依赖注入：
1、能注入的数据，有三类：
*基本类型和string
*其他bean类型（在配置文件中或注解配置过的bean）
*复杂类型/集合类型
2、注入的方式，有三种：
第一种：使用构造函数提供
使用的标签：constructor-arg
标签的位置：bean里
标签中的属性：
* type：指定注入数据的类型，也是构造函数中参数的类型。
* index：要注入的数据在构造函数中的位置。
* name：构造函数中指定参数。
* value：用于提供基本类型和string类型的数据。
* ref：用于指定其他的bean类型数据。
<bean id="acountservice" class="acountservice.acountserviceimp">
<constructor-arg name="name" value="rt"></constructor-arg>
<constructor-arg name="age" value="21"></constructor-arg>
<constructor-arg name="birthday" ref="birthday"></constructor-arg>
</bean>
<bean id="birthday" class="java.util.date"></bean>
优势：获取bean对象时，注入数据是必须的操作。
弊端：改变了bean对象的实例化方式，如果创建对象时用不到这些数据，也必须提供。
第二种：使用set方法提供 更常用
涉及的标签：property
出现的位置：bean里
标签的属性：
* name：指定注入时所调用的set方法名称。
* value：用于提供基本类型和string类型的数据。
* ref：用于指定其他的bean类型数据。
优势：创建对象时没有明确的限制，可以直接使用默认的构造函数。
弊端：如果某个成员必须有值，则获取对象时有可能set方法没有执行。
复杂类型/集合类型的注入：
*用于给list结构的集合注入的标签：list arry set
*用于给map结构的集合注入的标签：map props
第三种：使用注解提供
用于创建对象的注解： 它们的功能和<bean>标签实现的功能一样
1、@component：把当前类对象存入spring容器中。
属性：value：用于指定bean的id。默认是当前类名，且首字母小写。
2、@controller：一般用于表现层
3、@service：一般用在业务层
4、@repository：一般用在持久层
以上三个注解的作用和@componet一样，是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"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemalocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
<!--告知spring在创建容器时要扫描的包，配置所需的标签不是在beans的约束中，而是
一个名称为context名称空间和约束中-->
<context:component-scan base-package="acountservice"></context:component-scan>
</beans>
用于注入数据的注解：它们的作用和bean中的<property>标签的作用一样
1、@autowired：
* 作用：自动按类型注入。
* 只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以成功注入。
* 如果ioc容器中没有任何bean的类型和要注入的变量类型匹配，则报错。
* 如果ioc容器中有多个匹配的类型时，在将变量名作为bean的id，继续查找匹配项。
* 出现位置：变量上，或者方法上。
2、@qualifier：
* 作用：在按照类型注入的基础上再按照名称注入。它在给类成员注入时不能单独使用（需要aotowired）。但是在给方法参数注入时可以。
* 属性：value：用于指定注入bean的id。
3、@resource：
* 作用：直接按照bean的id注入，可以单独使用。
* 属性：name：bean的id。
4、@value：
* 作用：用于注入基本类型和string类型的数据。
* 属性：value：用于指定数据的值。可以使用spring的spel表达式。${表达式}
用于改变作用范围的注解：它们的作用和bean中的scope属性作用一样
1、@scope：
* 作用：指定bean的作用范围。
* 属性：value：指定范围的取值：singleleton prototype
和生命周期相关的注解：它们的作用和bean中的init-method 和 destroy-method 属性的作用一样
1、@predestroy
* 作用：用于指定销毁方法
2、@postconstruct
* 作用：用于指定初始化方法
spring中的新注解：
虽然上面的描述中已经使用了注解来配置，但是任然需要xml文件。
解决方案：创建一个配置类。
1、@configuration
* 作用：指定当前类是一个配置类。
2、@componetscan
* 作用：指定spring在创建容器时需要扫描的包
* 属性：value：它和basepackeages的作用一样，都用于指定创建容器时需要扫描的包，相当于xml的：<context:component-scan base-package="acountservice"></context:component-scan>
3、@bean
* 作用：将当前方法的返回值作为bean对象存入ioc容器。
* 属性：name：指定bean 的id，默认是方法名称。
* 细节：使用注解配置方法时，如果方法有参数，spring会在容器中查找有没有可用的bean对象，查找方式和aoutowired一样。
4、@import
* 作用：用于导入其他配置类。
* 属性：value：指定其他配置类的字节码。、
使用import注解的类是父配置类，导入的是子配置类。
5、@propertysource
* 作用：用于指定properties文件的位置。
* 属性：value：文件的名称和路径。 关键字：classpath：表示类路径下。
spring整合junit的配置。
1、导入jar坐标。
2、使用junit提供的一个注解把原有的main方法替换成spring提供的。
@runwith(springjunit4classrunner.clsss)
3、告知spring的运行器，spring和ioc创建是基于xml还是基于注解，且说明位置。
@contextconfiguration
location:指定xml文件的位置，加上classpath，表示在类路径下。
classes：指定注解类所在位置。
当使用spring5.x时，要求junit必须是4.12及以上。
aop：
动态代理:
特点:字节码随用随创建,随用随加载.
作用:不修改源码的基础上对方法增强.
分类:基于接口的动态代理 基于子类的动态代理.
基于接口的动态代理:
1.涉及的类:proxy
2.提供者:jdk
3.如何创建代理对象:newproxyinstance方法.
4.创建代理对象的要求:被代理类最少实现一个接口.
5.newproxyinstance方法的参数:
* classloader:类加载器. 用于加载代理对象的字节码,和被代理对象使用相同的类加载器. 固定写法.
* class[] :字节码数组. 用于让代理对象和被代理对象有相同的方法. 固定写法.
* invocationhandler: 用于提供增强的代码. 它是让我们写如何代理. 一般都是写一个该接口的实现类,通常是匿名内部类,但不是必须的.
6.invoke方法的作用: 执行被代理对象的任何接口方法都经过改方法(拦截作用)
7.invoke方法的参数:
* proxy:代理对象的引用.
* method: 当前执行的方法.
* args :当前执行方法所需的参数.
* 返回值: 和被代理对象方法有相同的返回值.
问题引入：
在转账案例中，分析可知，应该使用threadlocal对象把connection和当前线程绑定，从而使一个线程只能有一个能控制事务的对象。
aop概述：
aop：aspect oriented programming 。面向切面编程。
作用：在程序运行期间，不修改源码对已有的方法进行增强。
优势：减少重复代码，提高开发效率，维护方便。
实现方式：动态代理。
spring中的aop：spring中的aop就是通过配置的方式，实现aop功能 。
1、引入依赖。
2、添加配置文件<aop:aspectj-autoproxy>自动生成代理
3、写切面类（重复的模块），并用@component @aspect
4、申明各种通知。可以在通知方法中声明类型为 joinpoint的参数，用来访问被代理方法的参数。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
浅析我对 String、StringBuilder、StringBuffer 的理解
使用IDEA搭建SSM框架的详细教程(spring + springMVC +MyBatis)
Springboot整合freemarker 404问题解决方案
引入mybatis-plus报 Invalid bound statement错误问题的解决方法
网友评论