扩充：贝叶斯定理答案见底。
设计模式对关于面向对象问题的具体解决方案．
1，单例多例
在设计单例模式时，要注意两个点
1.构造方法要私有
2.成员变量要私有
3.创建对象所用的方法要被synchronized修饰.(因为方法体中会涉及到判断当前成员对象是否为空，在饿汉模式下，会有多个线程来访问该方法，为了防止判断访问结果同时为空，从而创建多个对象，就要被synchronized修饰)
2，模版
所谓模板板式，就是在父类中定义算法的主要流程，而把一些个性化的步骤延迟到子类中去实现，父类始终控制着整个流程的主动权，子类只是辅助父类实现某些可定制的步骤
父类
public abstract class FatherClass {
//人生
public final void 人生(){
学习();
工作();
爱情();
}
//学习
public void 学习(){
System.out.println("=========放学回家学到晚上12点不许睡觉===========");
}
//工作
public void 工作(){
System.out.println("============稳定就好===============");
}
//爱情(放飞自我)
public abstract void 爱情();
}
继承父类的类
package com.apesource.test;
//儿子
public class SonClass extends FatherClass{
@Override
public void 学习() {
System.out.println("=========开心就好，及格万岁============");
}
@Override
public void 爱情() {
System.out.println("======肤白貌美大长腿.....=======");
}
}
如果该方法被重写，那么结果是子类的内容。反之，则是父类的内容
- Spring中jdbcTemplate、hibernateTemplate等以Template结尾的
- 对数据库操作的类，它们就使用到模板模式。一般情况下，我们都是使用继承的方式来实现模板模式，但是Spring并没有使用这种方式，而是使用Callback模式与模板方法配合，既达到了代码复用的效果，同时增加了灵活性。
3，工厂
一个工厂可以根据传入参数的不同，而创建出来不同的对象。
4，代理（静态代理，动态代理）
功能：
1.中介隔离作用
2.方法增强
一.静态代理，静态代理中，代理在代码执行前已经被创建出来了。
动态代理，是代码执行的时候被创建出来的， 1.基于接口（jdk自带）2.基于子类（第三方）
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.InvocationHandler;子类
public class Test03 {
public static void main(String[] args) {
//1.创建被代理对象
ISinger teng = new TengEr();
//2.创建代理对象
ISinger jinJiRen = (ISinger)Enhancer.create(teng.getClass(), new InvocationHandler() {
@Override
public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
Object obj = method.invoke(teng,objects);
return obj;
}
});
//3.使用
jinJiRen.sing();
}
}
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Test02 {
public static void main(String[] args) {
//1.被代理对象
ISinger zhouJieLun = new ZhouJieLun();
/**
* 2.创建代理对象
* ClassLoader loader被代理对象的类的加载器
* Class<?>[] interfaces,被代理对象的类的字节数组
* InvocationHandler h处理器对象
* */
ISinger jinJiRen = (ISinger) Proxy.newProxyInstance(zhouJieLun.getClass().getClassLoader(), zhouJieLun.getClass().getInterfaces(), new InvocationHandler() {
/**
* Object proxy, 被代理对象的引用
* Method method,被代理对象类中的所有方法
* Object[] args 被代理对象类中的所有方法的参数
* Object 被代理对象类中的所有方法的返回值
*
* */
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//方法增强
System.out.println("挑一个舞，打个球~~~");
Object obj = method.invoke(zhouJieLun,args);//执行周杰伦唱歌方法,(执行被代理对象中的所有方法)
return obj;
}
});
//3.消费使用
jinJiRen.sing();
}
}
事务管理
1，在转账服务时，更新数据库时，可能会发生异常，就会导致金额不对
解决方法，1.被调用到的dao层语句，都拿着同一个对象，这个对象可以实现锁的功能。那么就要在dao层query和update语句中，增加一个Connection对象。threadLocal可以充当sql语句的锁对象
因为threadlocal有一个线程们的公共区域，完全可以实现当公共区有一个connection的时候，线程们完全不需要再考虑在去造很多connection。
ThreadLocal叫做线程变量，意思是ThreadLocal中填充的变量属于当前线程，该变量对其他线程而言是隔离的，也就是说该变量是当前线程独有的变量。ThreadLocal为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量。
2.service层中，调用事务管理，当异常发生时，实现事务的回滚
①在dao层用到的连接工具类
package com.apesource.util;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
/**
* @author * @version 1.0
* @since 2023/9/15
*/
public class ConnectionUtil {
//1.线程区域对象
ThreadLocal<Connection> threadLocal = new ThreadLocal<Connection>();
//2.数据源
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
Connection connection = null;
//获取连接
public Connection createConn(){
try {
//1.线程区域
connection = threadLocal.get();
//2.判断
if (connection ==null){
//创建连接
connection = dataSource.getConnection();
//保存
threadLocal.set(connection);
}
return connection;
} catch (SQLException throwables) {
throwables.printStackTrace();
}
return null;
}
//关闭连接
public void closeConn(){
threadLocal.remove();//解除绑定
}
}
在dao层的每一个语句都装配工具类
//装配连接工具类
ConnectionUtil connectionUtil;
public void setConnectionUtil(ConnectionUtil connectionUtil) {
this.connectionUtil = connectionUtil;
}
@Override
public void save(Student student) {
try {
queryRunner.update(connectionUtil.createConn(),"insert into student(sname,shobby,smoney) value(?,?,?)",student.getSname(),student.getShobby(),student.getSmoney());
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
②在service层用到的事务管理工具类
package com.apesource.util;
import java.sql.SQLException;
/**
* @author
* @version 1.0
* @since 2023/9/15
*/
public class TransactionUtil {
//装配连接工具类
ConnectionUtil connectionUtil;
public void setConnectionUtil(ConnectionUtil connectionUtil) {
this.connectionUtil = connectionUtil;
}
//开启事务
public void beginTransaction(){
try {
connectionUtil.createConn().setAutoCommit(false);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//提交事务
public void commitTransaction(){
try {
connectionUtil.createConn().commit();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//回滚事务
public void rollbackTransaction(){
try {
connectionUtil.createConn().rollback();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
//关闭事务
public void closeTransaction(){
try {
connectionUtil.createConn().close();//关闭连接
connectionUtil.closeConn();//解除绑定
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
service里的用到的事务管理
@Override
public void transfer(String sourceName, String targetName, int money) {
try {
//开启事务
transactionUtil.beginTransaction();
//1.查询用户信息
Student sourceStudent = dao.findByName(sourceName);
Student targetStudent = dao.findByName(targetName);
//2.java代码中实现转账
sourceStudent.setSmoney(sourceStudent.getSmoney()-money);
targetStudent.setSmoney(targetStudent.getSmoney()+money);
//3.修改数据库
dao.update(sourceStudent);
int a = 10/0;//模拟异常
dao.update(targetStudent);
//提交事务
transactionUtil.commitTransaction();
} catch (Exception e) {
e.printStackTrace();
//回滚事务
transactionUtil.rollbackTransaction();
}finally {
//关闭事务
transactionUtil.closeTransaction();
}
}
优化方法
优化方法
采用Beanfactory创建代理对象，代理对象可以用来方法增强，可以将被代理对象的方法不经过污染，就可以实现事务管理。
在这个案例中,controller是消费者
<!--注入被代理service-->
<bean id="serviceImp" class="com.apesource.service.StudentServiceImp">
<property name="dao" ref="daoImp"></property>
</bean>
<!--注入代理service-->
<bean id="proxySerivce" class="com.apesource.service.StudentServiceImp" factory-bean="factory" factory-method="createProxy"></bean>
<bean id="factory" class="com.apesource.factory.BeansFactory">
<property name="transactionUtil" ref="transactionUtil"></property>
<property name="toProxyService" ref="serviceImp"></property>
</bean>
<!--注入controller-->
<bean id="controllerImp" class="com.apesource.controller.StudentControllerImp">
<property name="studentService" ref="proxySerivce"></property>
</bean>
抽取方法用到了代理对象 ，BeansFactory代码如下：
package com.apesource.factory;
import com.apesource.service.IStudentService;
import com.apesource.util.TransactionUtil;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* @author
* @version 1.0
* @since 2023/9/15
*/
public class BeansFactory {
//装配被代理业务对象
IStudentService toProxyService;
public void setToProxyService(IStudentService toProxyService) {
this.toProxyService = toProxyService;
}
//装配事务工具类
TransactionUtil transactionUtil;
public void setTransactionUtil(TransactionUtil transactionUtil) {
this.transactionUtil = transactionUtil;
}
//创建代理对象
public IStudentService createProxy(){
return (IStudentService)Proxy.newProxyInstance(toProxyService.getClass().getClassLoader(), toProxyService.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object obj = null;//主业务方法
try {
transactionUtil.beginTransaction();
obj = method.invoke(toProxyService,args);
transactionUtil.commitTransaction();
} catch (Exception e) {
e.printStackTrace();
transactionUtil.rollbackTransaction();
} finally {
transactionUtil.closeTransaction();
}
return obj;
}
});
}
}
八年后的重逢：贝叶斯定理是一则随机事件的条件概率(或边缘概率)的定理，其中P(A|B)是在B发生的情况下A发生的可能性。也就是说，如果你喜欢他，那么他就会喜欢你。如果你对他好，他也会对你好的。因此，如果你表白，你需要相信他，将全部的情感完全吐露给对方，将真诚当成一生的信念，投入到爱情中，去充实彼此的关系，全心全意地去经营彼此的关系，将相互接纳、宽容、体谅和支持当作最可贵的宝贵财富。
