秦怀杂货店

秦怀杂货店 查看完整档案

深圳编辑  |  填写毕业院校  |  填写所在公司/组织 aphysia.cn 编辑
编辑

山高水长,纵使缓慢,驰而不息。
公众号:秦怀杂货店

个人动态

秦怀杂货店 发布了文章 · 11月28日

【Java基础】-- isAssignableFrom的用法详细解析

[TOC]
最近在java的源代码中总是可以看到isAssignableFrom()这个方法,到底是干嘛的?怎么用?

1. isAssignableFrom()是干什么用的?

首先我们必须知道的是,java里面一切皆对象,类本身也是会当成对象来处理,主要体现在类的.class文件,其实加载到java虚拟机之后,也是一个对象,它就是Class对象,全限定类名:java.lang.Class

那这个isAssignableFrom()其实就是Class对象的一个方法:

    /**
     * Determines if the class or interface represented by this
     * {@code Class} object is either the same as, or is a superclass or
     * superinterface of, the class or interface represented by the specified
     * {@code Class} parameter. It returns {@code true} if so;
     * otherwise it returns {@code false}. If this {@code Class}
     * object represents a primitive type, this method returns
     * {@code true} if the specified {@code Class} parameter is
     * exactly this {@code Class} object; otherwise it returns
     * {@code false}.
     *
     * <p> Specifically, this method tests whether the type represented by the
     * specified {@code Class} parameter can be converted to the type
     * represented by this {@code Class} object via an identity conversion
     * or via a widening reference conversion. See <em>The Java Language
     * Specification</em>, sections 5.1.1 and 5.1.4 , for details.
     *
     * @param cls the {@code Class} object to be checked
     * @return the {@code boolean} value indicating whether objects of the
     * type {@code cls} can be assigned to objects of this class
     * @exception NullPointerException if the specified Class parameter is
     *            null.
     * @since JDK1.1
     */
    public native boolean isAssignableFrom(Class<?> cls);

native关键字描述,说明是一个底层方法,实际上是使用c/c++实现的,java里面没有实现,那么这个方法是干什么的呢?我们从上面的注释可以解读:

如果是A.isAssignableFrom(B)
确定一个类(B)是不是继承来自于另一个父类(A),一个接口(A)是不是实现了另外一个接口(B),或者两个类相同。主要,这里比较的维度不是实例对象,而是类本身,因为这个方法本身就是Class类的方法,判断的肯定是和类信息相关的。

也就是判断当前的Class对象所表示的类,是不是参数中传递的Class对象所表示的类的父类,超接口,或者是相同的类型。是则返回true,否则返回false。

2.代码实验测试

2.1 父子继承关系测试

class A{
}
class B extends A{
}
class C extends B{
}
public class test {
    public static void main(String[] args) {
        A a = new A();
        B b = new B();
        B b1 = new B();
        C c = new C();
        System.out.println(a.getClass().isAssignableFrom(a.getClass()));
        System.out.println(a.getClass().isAssignableFrom(b.getClass()));
        System.out.println(a.getClass().isAssignableFrom(c.getClass()));
        System.out.println(b1.getClass().isAssignableFrom(b.getClass()));

        System.out.println(b.getClass().isAssignableFrom(c.getClass()));

        System.out.println("=====================================");
        System.out.println(A.class.isAssignableFrom(a.getClass()));
        System.out.println(A.class.isAssignableFrom(b.getClass()));
        System.out.println(A.class.isAssignableFrom(c.getClass()));

        System.out.println("=====================================");
        System.out.println(Object.class.isAssignableFrom(a.getClass()));
        System.out.println(Object.class.isAssignableFrom(String.class));
        System.out.println(String.class.isAssignableFrom(Object.class));
    }
}

运行结果如下:

true
true
true
true
true
=====================================
true
true
true
=====================================
true
true
false

从运行结果来看,C继承于BB继承于A,那么任何一个类都可以isAssignableFrom其本身,这个从中文意思来理解就是可以从哪一个装换而来,自身装换而来肯定是没有问题的,父类可以由子类装换而来也是没有问题的,所以A可以由B装换而来,同时也可以由子类的子类转换而来。

上面的代码也说明一点,所有的类,其最顶级的父类也是Object,也就是所有的类型都可以转换成为Object

2.2 接口的实现关系测试

interface InterfaceA{
}

class ClassB implements InterfaceA{

}
class ClassC implements InterfaceA{

}
class ClassD extends ClassB{

}
public class InterfaceTest {
    public static void main(String[] args) {
        System.out.println(InterfaceA.class.isAssignableFrom(InterfaceA.class));
        System.out.println(InterfaceA.class.isAssignableFrom(ClassB.class));
        System.out.println(InterfaceA.class.isAssignableFrom(ClassC.class));
        System.out.println(ClassB.class.isAssignableFrom(ClassC.class));
        System.out.println("============================================");

        System.out.println(ClassB.class.isAssignableFrom(ClassD.class));
        System.out.println(InterfaceA.class.isAssignableFrom(ClassD.class));
    }
}

输出结果如下:

true
true
true
false
============================================
true
true

从上面的结果看,其实接口的实现关系和类的实现关系是一样的,没有什么区别,但是如果BC都实现了同一个接口,他们之间其实是不能互转的。

如果B实现了接口AD继承了B,实际上D是可以上转为A接口的,相当于D间接实现了A,这里也说明了一点,其实继承关系和接口实现关系,在isAssignableFrom()的时候是一样的,一视同仁的。

3.总结

isAssignableFrom是用来判断子类和父类的关系的,或者接口的实现类和接口的关系的,默认所有的类的终极父类都是Object。如果A.isAssignableFrom(B)结果是true,证明B可以转换成为A,也就是A可以由B转换而来。

这个方法在我们平时使用的不多,但是很多源码里面判断两个类之间的关系的时候,(注意:是两个类的关系,不是两个类的实例对象的关系!!!),会使用到这个方法来判断,大概因为框架代码或者底层代码都是经过多层抽象,做到容易拓展和解耦合,只能如此。

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

JDBC【4】-- SPI底层原理解析

前面已经讲过SPI的基本实现原理了,demo也基本实现了,再来说说SPI。

http://aphysia.cn/archives/jd...

背景:SPI是什么?
SPI,即是Service Provider Interface,是一种服务提供(接口实现)发现机制,可以通过ClassPath路径下的META-INF/Service文件查找文件,加载里面定义的类。
一般可以用来启用框架拓展和替换组件,比如在最常见的数据库连接JDBC中,java.sql.Driver,不同的数据库产商可以对接口做不一样的实现,但是JDK怎么知道别人有哪些实现呢?这就需要SPI,可以查找到接口的实现,对其进行操作。
用两个字解释:解耦

再简单点说?
就是Java核心包不知道第三方的包会怎么实现一个接口,定义了一个规则:你要对这个类拓展,那你就把你的实现类配置到一个文件里面,文件名就是你要拓展的接口,这样子,我只要用ServiceLoader加载接口,我就可以获取到实现类的实例。

对于java核心包来说,我不知道你要怎么实现接口,但是只要你按我说的做,配置好,我就能保证你只要引入你自己的包,我就可以运行到你的代码。

核心代码如下:

    ServiceLoader<DBConnectionService>  serviceLoader= ServiceLoader.load(DBConnectionService.class);

所以我们此时假设自己对ServiceLoader已经十分好奇了,这是什么?这是怎么实现的?这么牛逼?

那就看源码?夜深人静刚刚好,白天也看不下去。

这里需要注意的是,这个ServiceLoader是一个泛型类,实现了Iterable,说明了什么?说明它的功能有一部分和集合是差不多的,可以将多个服务的实现类加载在里面!!!可以通过遍历的方式,一一取出来

先看看ServiceLoader的类成员接口,不急着看load()函数:

public final class ServiceLoader<S>
    implements Iterable<S>
{
    // 读取配置文件的路径
    private static final String PREFIX = "META-INF/services/";

    // 加载的服务类或者接口的实现类
    private final Class<S> service;

    // 类加载器
    private final ClassLoader loader;

    // 访问控制器
    private final AccessControlContext acc;

    // 已加载的服务类集合
    private LinkedHashMap<String,S> providers = new LinkedHashMap<>();

    // 内部类,真正加载服务类的迭代器
    private LazyIterator lookupIterator;

    ...
}

现在来看load()函数,其实里面调用的也还是serviceLoader本身的构造器,两个load方法

  • 一个只需要传入需要实现的服务接口service
  • 另一个则是需要同时传入类加载器loader
    // 当前线程的类加载器作为默认加载器
    public static <S> ServiceLoader<S> load(Class<S> service) {
        // 获取类加载器
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        // 调用另外一个加载器
        return ServiceLoader.load(service, cl);
    }

    // 两个参数的加载方法
    public static <S> ServiceLoader<S> load(Class<S> service,
                                            ClassLoader loader)
    {
        return new ServiceLoader<>(service, loader);
    }

我们还是来看serviceLoader的构造器:

    private ServiceLoader(Class<S> svc, ClassLoader cl) {
        // 要加载的接口
        service = Objects.requireNonNull(svc, "Service interface cannot be null");
        // 加载器,如果为null则默认使用系统加载器进行加载
        loader = (cl == null) ? ClassLoader.getSystemClassLoader() : cl;
        // 控制访问器
        acc = (System.getSecurityManager() != null) ? AccessController.getContext() : null;
        // 重新加载
        reload();
    }

看重新加载的方法:

    public void reload() {
        // 清空已经加载的服务类
        providers.clear();
        // 初始化查找加载类的迭代器
        lookupIterator = new LazyIterator(service, loader);
    }

查找加载类的迭代器,到底是什么?从名字来看,是一个懒加载器,就是延迟加载,从名字来看,大概能猜到,这个就是使用的时候才加载,真的是这样么???接着看下去:

上面 👆 我们说到ServiceLoader其实是一个泛型类,实现了Iterator接口,说明它可以被遍历,遍历的元素是什么呢?就是上面所说的成员变量LinkedHashMap<String,S> providers,实现的服务都加载在里面了。

那我们就看看遍历的时候怎么取的?
这就涉及到了Iterable接口的方法foreach()了,我们就来看看。
总所周知,Iterable接口的方法如下:

    Iterator<T> iterator();
    default void forEach(Consumer<? super T> action) {
        Objects.requireNonNull(action);
        for (T t : this) {
            action.accept(t);
        }
    }
    default Spliterator<T> spliterator() {
        return Spliterators.spliteratorUnknownSize(iterator(), 0);
    }

那我猜遍历的方法应该被ServiceLoader实现的时候,已经重写了,果不其然:
看获取Iterator的方法实现,我们可以发现一个惊天㊙️密:也就是其实我们遍历的时候,优先是使用已知的集合迭代器,这个集合,就是存储我们的服务提供者的集合,也就是已经加载的服务类集合。如果这个集合已经遍历完成的时候,就会调用查找迭代器去查找,不管next()还是hasNext()方法,都是这样的。
同时已经加载的服务,是不可以被移除的,为了防止这一点,在移除的时候会返回异常。

    public Iterator<S> iterator() {
        return new Iterator<S>() {

            //  被查找到的已知的服务提供者的迭代器
            Iterator<Map.Entry<String,S>> knownProviders
                = providers.entrySet().iterator();

            // 如果已知的迭代器,也就是存储服务提供者的集合迭代器,如果这个有下一个元素,那么就会直接返回true,如果没有那么就会调用查找迭代器的hasNext()
            public boolean hasNext() {
                if (knownProviders.hasNext())
                    return true;
                return lookupIterator.hasNext();
            }

            public S next() {
                // 如果存储已知的服务提供者的迭代器还有下一个元素,那么直接取出来直接返回即可,否则就用查找迭代器去查找下一个
                if (knownProviders.hasNext())
                    return knownProviders.next().getValue();
                return lookupIterator.next();
            }

            // 不可以移除已经加载额服务提供者
            public void remove() {
                throw new UnsupportedOperationException();
            }

        };
    }

Iterator的其他方法呢?

当然是用了默认实现了,其他两个方法都加了default关键字,ServiceLoader没有去实现它,可以不实现,用默认实现就可以。

所以我们的重点是什么?当然是这个lookupIterator,它可是一个延迟加载器,为什么这么说,我觉得应该和上面的分析有关,先遍历已经加载的,然后没有了,才会使用这个延迟查找迭代器,从它的名字就可以很清楚的看出来,这其实就是一个查找的迭代器,别人都是迭代遍历已经存在的元素,它倒好,懒到一定程度了,用来查找。

废话少说,直接看看它怎么实现的,这么🐂 牛!
在回头看看前面初始化的时候,构造是这样子的:

        // 初始化查找加载类的迭代器
        lookupIterator = new LazyIterator(service, loader);

可以看到其实是将需要加载的服务接口以及类加载器传递进来了。
代码精简,看👇下面的代码加注解,应该很清晰了。

    private class LazyIterator
        implements Iterator<S>
    {
        // 需要加载的服务
        Class<S> service;
        // 类加载器
        ClassLoader loader;
        // 实现类的url(多个)
        Enumeration<URL> configs = null;
        // 实现类的全名(多个)
        Iterator<String> pending = null;
        // 迭代器中下一个实现类的全名
        String nextName = null;

        // 构造器其实没有什么操作,单纯保存
        private LazyIterator(Class<S> service, ClassLoader loader) {
            this.service = service;
            this.loader = loader;
        }

        // 获取下一个
        public S next() {
            // 如果控制访问器是空的
            if (acc == null) {
                // 调用获取下一个元素
                return nextService();
            } else {
                // 特权动作,重写的其实也是调用nextService()
                PrivilegedAction<S> action = new PrivilegedAction<S>() {
                    public S run() { return nextService(); }
                };
                // 通过控制访问器的特权访问,跳过检查
                return AccessController.doPrivileged(action, acc);
            }
        }
        // 是否有下一个元素
        public boolean hasNext() {
            if (acc == null) {
                // 如果访问控制器是null,那么久直接调用hasNextService方法
                return hasNextService();
            } else {
                // 生成特权动作
                PrivilegedAction<Boolean> action = new PrivilegedAction<Boolean>() {
                    public Boolean run() { return hasNextService(); }
                };
                // 使用访问控制器执行特权动作
                return AccessController.doPrivileged(action, acc);
            }
        }

        // 不可以移除
        public void remove() {
            throw new UnsupportedOperationException();
        }

        // 是否有下一个元素
        private boolean hasNextService() {
            // 如果下一个元素的全类名名字不为null,那么肯定是有下一个元素
            if (nextName != null) {
                return true;
            }
            // 如果这个实现类的url是空的,怎么办?加载进去
            if (configs == null) {
                try {
                    // 获取全名
                    String fullName = PREFIX + service.getName();
                    // 如果类加载器是null
                    if (loader == null)
                        // 通过全名,拿到全名的url,这个url其实就是根据名字找到的配置文件的路径
                        configs = ClassLoader.getSystemResources(fullName);
                    else
                        // 否则调用loader自身的方法获取
                        configs = loader.getResources(fullName);
                } catch (IOException x) {
                    fail(service, "Error locating configuration files", x);
                }
            }

            // 如果实现类的全限定类名是空的,那就肯定需要从文件里面读出来呀,因为文件名是接口,里面配置的是接口的实现类,pending保存的就是实现类
            while ((pending == null) || !pending.hasNext()) {
                // 如果需要读取的配置没有要读的了
                if (!configs.hasMoreElements()) {
                    // 直接返回false
                    return false;
                }
                // 否则需要解析配置文件里面的内容
                pending = parse(service, configs.nextElement());
            }
            // 下一个service的名字就更新为读取到的接口实现类,如果文件里面什么都没有配置,那就很有可能是空的。
            nextName = pending.next();
            return true;
        }

        // 获取下一个接口实现类,也就是服务
        private S nextService() {
            // 如果没有下一个服务,会抛异常
            if (!hasNextService())
                throw new NoSuchElementException();
            // 下一个实现类的名称,保存起来
            String cn = nextName;
            // 置空
            nextName = null;
            Class<?> c = null;
            try {
                // 通过反射来构造服务对象,就是实现类
                c = Class.forName(cn, false, loader);
            } catch (ClassNotFoundException x) {
                fail(service,
                     "Provider " + cn + " not found");
            }
            // 判断服务c是不是实现来自于service,两者是不是继承关系
            if (!service.isAssignableFrom(c)) {
                fail(service,
                     "Provider " + cn  + " not a subtype");
            }
            try {
                // 强装类型
                S p = service.cast(c.newInstance());
                // 将解析的服务实现放到已经发现的集合中
                providers.put(cn, p);
                // 返回当前的实现
                return p;
            } catch (Throwable x) {
                fail(service,
                     "Provider " + cn + " could not be instantiated",
                     x);
            }
            throw new Error();          // This cannot happen
        }
    }

通过上面的代码,其实我们可以清楚的看到,这个延迟加载器,会去读取配置类,以及实现的的接口,将实现类全类名放到configs,然后通过反射的形式构建实例对象,实例化之后才放到providers中,然后返回实现类对象。

值得注意的是,如果访问控制器是空的,那么就会调用特权执行:AccessController.doPrivileged(action, acc);,获取到服务实现的时候,也会判断是不是实现来自于我们需要实现的接口,否则会报错,调用的是service.isAssignableFrom(c)

上面还有一段解析配置的代码没有说明,补上:

    private Iterator<String> parse(Class<?> service, URL u)
        throws ServiceConfigurationError
    {
        // 输入流
        InputStream in = null;
        // buffer读入
        BufferedReader r = null;
        ArrayList<String> names = new ArrayList<>();
        try {
            in = u.openStream();
            r = new BufferedReader(new InputStreamReader(in, "utf-8"));
            int lc = 1;
            // 按照每一行来读入
            while ((lc = parseLine(service, u, r, lc, names)) >= 0);
        } catch (IOException x) {
            fail(service, "Error reading configuration file", x);
        } finally {
            try {
                if (r != null) r.close();
                if (in != null) in.close();
            } catch (IOException y) {
                fail(service, "Error closing configuration file", y);
            }
        }
        // 返回的其实是实现类全限定名的集合迭代器
        return names.iterator();
    }

    private int parseLine(Class<?> service, URL u, BufferedReader r, int lc,
                          List<String> names)
        throws IOException, ServiceConfigurationError
    {
        String ln = r.readLine();
        if (ln == null) {
            return -1;
        }
        // 对于#号后面的内容不加载,直接忽略掉
        int ci = ln.indexOf('#');
        if (ci >= 0) ln = ln.substring(0, ci);
        ln = ln.trim();
        int n = ln.length();
        if (n != 0) {
            if ((ln.indexOf(' ') >= 0) || (ln.indexOf('\t') >= 0))
                fail(service, u, lc, "Illegal configuration-file syntax");
            int cp = ln.codePointAt(0);
            if (!Character.isJavaIdentifierStart(cp))
                fail(service, u, lc, "Illegal provider-class name: " + ln);
            for (int i = Character.charCount(cp); i < n; i += Character.charCount(cp)) {
                cp = ln.codePointAt(i);
                if (!Character.isJavaIdentifierPart(cp) && (cp != '.'))
                    fail(service, u, lc, "Illegal provider-class name: " + ln);
            }
            // 没有加载过才会添加进去
            if (!providers.containsKey(ln) && !names.contains(ln))
                names.add(ln);
        }
        return lc + 1;
    }

到这里,serviceLoader的内容就解读完毕了,思想挺好的,有两个迭代器,一个是提供服务的集合本身的迭代器,迭代完成之后,才会去使用延迟调用lookup迭代器,触发寻找操作,如果查找了,那么就加载到集合中,下次就不用再找了。

查找的时候,直接根据该路径下的文件,文件名就是接口,接口里面每一行都是接口的实现类。

实例化接口实现类的时候,其实是使用了反射,然后判断类型之后,类型转换成为⤴️上转型,放到已经发现的服务集合中,返回。

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

Mybatis【4】-- 关于Mybatis别名定义

代码直接放在Github仓库【https://github.com/Damaer/Myb... 】,可直接运行,就不占篇幅了。

我们下面需要改进的是别名,也趁这个机会介绍一下别名的作用。

其实在我们实际开发中,大多数情况下,一个mapper.xml文件对应的是对一个对象的操作,当前的mapper如下:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper 
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper1">
    <insert id="insertStudent" parameterType="bean.Student">
        insert into student(name,age,score) values(#{name},#{age},#{score})
    </insert>
</mapper>

我们可以看出:

parameterType有时候会写很长很长,每写一个sql我们就要使用parameterType传值或者使用返回类型,意思就是这个parameterType太长了,有没有什么办法可以让我们就写类名就可以了

其实是有的!!!那就是别名,mybatis可以让我们起一个别名给它,别名定义是在mybatis.xml主配置文件中。注意别名标签应该定义在<properties></properties>后面,在<environments></environments>前面,顺序不能颠倒。<typeAliases></typeAliases>这个标签里面可以定义很多别名<typeAlias/>

<!-- 别名,对数据对象操作全名太长,需要使用别名 -->
<typeAliases>
    <typeAlias type="bean.Student" alias="Student"/>
</typeAliases>

我们在上面的别名中的意思是给bean包下Student这个类起了一个别名,名字叫Student,那么我们就可以使用了,很简单:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper 
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper1">
    <insert id="insertStudent" parameterType="Student">
        insert into student(name,age,score) values(#{name},#{age},#{score})
    </insert>
</mapper>

但是要是bean里面有很多类,我们是不是要写很多别名呢?其实不用,我们可以观察到<typeAliases></typeAliases>这个标签下面有一个<package/>标签,它的作用就体现出来了。将指定的包中的类的简单类名当做别名。

<typeAliases>
      <!-- 配置一个类的别名 -->
      <!-- <typeAlias type="com.aphysia.beans.Student" alias="Student"/> -->
    <!--直接使用类名即可,对于整个包的路径配置(别名),简单快捷 -->
      <package name="bean"/>
</typeAliases>

贴代码

在这里贴一下代码,代码结构如下:

bean包下的Student类:

package bean;

public class Student {
    private Integer id;
    private String name;
    private int age;
    private double score;
    public Student(){

    }
    public Student(String name, int age, double score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [id=" + id + ", name=" + name + ", age=" + age
                + ", score=" + score + "]";
    }
    
}

dao包下面的IStudentDao接口:

package dao;
import bean.Student;
public interface IStudentDao {
    public void insertStu(Student student);
}

dao包下的实现类:

import bean.Student;
import org.apache.ibatis.session.SqlSession;
import utils.MyBatisUtils;
public class StudentDaoImpl implements IStudentDao {
    private SqlSession sqlSession;
    public void insertStu(Student student) {
        //加载主配置文件
        try {
            sqlSession=MyBatisUtils.getSqlSession();
            sqlSession.insert("mapper1.insertStudent",student);
            sqlSession.commit();
        } finally{
            if(sqlSession!=null){
                sqlSession.close();
            }
        }
    }
}

util包下面的工具类:

public class MyBatisUtils {

    /*    public SqlSession getSqlSession(){
            InputStream is;
            try {
                is = Resources.getResourceAsStream("mybatis.xml");
                return new SqlSessionFactoryBuilder().build(is).openSession();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return null;
        }*/
    static private SqlSessionFactory sqlSessionFactory;

    static public SqlSession getSqlSession() {
        InputStream is;
        try {
            is = Resources.getResourceAsStream("mybatis.xml");
            if (sqlSessionFactory == null) {
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            }
            return sqlSessionFactory.openSession();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

resource资源目录下mapper目录下的mapper.xml(mapper1.xml也一样内容,只是里面namespace不一样):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="mapper1">
    <!--此处parameterType可以省略不写-->
    <insert id="insertStudent" parameterType="Student">
        insert into student(name,age,score) values(#{name},#{age},#{score})
    </insert>
</mapper>

jdbc_mysql.properties文件(jdbc_oracle.properties是空文件),主要是配置了数据库连接相关的信息:

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.user=root
jdbc.password=123456

log4j.properties,主要是配置了log日志相关的信息:

log4j.prpp
log4j.rootLogger=DEBUG, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=[service] %d - %c -%-4r [%t] %-5p %c %x - %m%n
log4j.logger.java.sql.Statement = debug
log4j.logger.java.sql.PreparedStatement = debug
log4j.logger.java.sql.ResultSet =debug

主配置文件mybatis.xml,这个是mybatis的入口配置文件:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 配置数据库文件 -->
    <properties resource="jdbc_mysql.properties">

    </properties>
    <!-- 别名,对数据对象操作全名太长,需要使用别名 -->
    <typeAliases>
        <!--<typeAlias type="bean.Student" alias="Student"/>-->
        <!--直接使用类名即可,对于整个包的路径配置(别名),简单快捷 -->
        <package name="bean"/>
    </typeAliases>
    <!-- 配置运行环境 -->
    <!-- default 表示默认使用哪一个环境,可以配置多个,比如开发时的测试环境,上线后的正式环境等 -->
    <environments default="mysqlEM">
        <environment id="mysqlEM">
            <transactionManager type="JDBC">
            </transactionManager>
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.user}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 注册映射文件 -->
    <mappers>
        <mapper resource="mapper/mapper.xml"/>
        <mapper resource="mapper/mapper1.xml"/>
    </mappers>
</configuration>

test.sql:这是我们创建数据库的时候使用的sql

#创建数据库
CREATE DATABASE `test` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
#创建数据表
CREATE TABLE `student` ( `id` INT NOT NULL AUTO_INCREMENT , `name` VARCHAR(20) NOT NULL ,
`age` INT NOT NULL , `score` DOUBLE NOT NULL , PRIMARY KEY (`id`)) ENGINE = MyISAM;

测试文件MyTest.java:

public class MyTest {
    private IStudentDao dao;
    @Before
    public void Before(){
        dao=new StudentDaoImpl();
    }
    @Test
    public void testInsert(){
        Student student=new Student("1ADAS",23,100);
        dao.insertStu(student);
    }
}

Maven配置文件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.test</groupId>
    <artifactId>test</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!-- mybatis核心包 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.3.0</version>
        </dependency>
        <!-- mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.29</version>
        </dependency>
        <!-- junit测试包 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!-- 日志文件管理包 -->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.12</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.12</version>
        </dependency>
    </dependencies>
</project>

至此,整个项目的代码结束。

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

Mybatis【3】-- Mybatis使用工具类读取配置文件以及从属性读取DB信息

代码直接放在Github仓库【https://github.com/Damaer/Myb... 】,可直接运行,就不占篇幅了。

1.使用工具类获取sqlSession实例对象

在上一个demo中,处理了多个namespace的问题,那么我们可以看到代码还是会有一定的冗余,比如下面这段代码中我们每一个增删改查操作都需要读取一遍配置文件:

public class StudentDaoImpl implements IStudentDao {
    private SqlSession sqlSession;
    public void insertStu(Student student) {
        try {
            InputStream inputStream;
            inputStream = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession=sqlSessionFactory.openSession();
            sqlSession.insert("mapper1.insertStudent",student);
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(sqlSession!=null){
                sqlSession.close();
            }
        }
    }
}

我们的思路应该是写一个工具类来替我们获取配置文件的信息,只要返回一个sqlSession实例就可以了。所以就有了MyBatisUtils.class,下面这样的方式,只要使用sqlSession=MyBatisUtils.getSqlSession();就可以获取到sqlsession的实例。

public class MyBatisUtils {
    public SqlSession getSqlSession(){
        InputStream is;
        try {
            is = Resources.getResourceAsStream("mybatis.xml");
            return new SqlSessionFactoryBuilder().build(is).openSession();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

但是以上的方式并不是最好的,还是会浪费资源,如果sqlsession已经存在了,这段代码还是会去创建一个新的实例对象。我们知道sqlsession没有可修改的属性,是线程安全的,所以我们需要把它改写成单例模式。

public class MyBatisUtils {
    static private SqlSessionFactory sqlSessionFactory;
    // 单例模式
    static public SqlSession getSqlSession() {
        InputStream is;
        try {
            is = Resources.getResourceAsStream("mybatis.xml");
            if (sqlSessionFactory == null) {
                sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
            }
            return sqlSessionFactory.openSession();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }
}

使用的时候只需要获取即可

sqlSession=MyBatisUtils.getSqlSession();

2.DB配置改造成读取配置文件

现在我们需要将DB使用配置文件读取,不是用xml配置,很多人会问,为什么这样做,有人可能会回答是因为改动的时候容易改,但是xml改动的时候不是挺容易改么?

其实,写到属性文件的原因与上面的一样,就是为了更好改,要是上线了需要该数据库我们只需要改动<properties resource="jdbc_mysql.properties">这一个地方就可以了,xml文件就变得更加简洁清晰了。

原来在mybatis.xml文件里配置的是:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
  <configuration>
          <!-- 配置运行环境 -->
          <!-- default 表示默认使用哪一个环境,可以配置多个,比如开发时的测试环境,上线后的正式环境等 -->
          <environments default="mysqlEM">
              <environment id="mysqlEM">
                <!--事务管理器-->
                  <transactionManager type="JDBC">        
                  </transactionManager>
                <!--数据源-->
                  <dataSource type="POOLED">
                      <property name="driver" value="com.mysql.jdbc.Driver"/>
                      <property name="url" value="jdbc:mysql://127.0.0.1:3306/test"/>
                      <property name="username" value="root"/>
                      <property name="password" value="123456"/>
                  </dataSource>
              </environment>
          </environments>
          <!-- 注册映射文件 -->
          <mappers>
              <mapper resource="mapper/mapper.xml"/>
            <mapper resource="mapper/mapper1.xml"/>
          </mappers>
  </configuration>

现在我们定义一个jdbc-mysql.properties文件,将数据库连接的属性直接写进属性文件里(我们可以有好几个不一样的.properties文件,配置着不同的数据库):

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.user=root
jdbc.password=123456

将mybatis.xml改造成(注意下面需要配置属性文件,然后才能在environment标签里面使用,直接使用key就可以了,属性文件配置是按照key-value的模式配置的):

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
  <configuration>
        <!-- 配置数据库文件 -->
        <properties  resource="jdbc_mysql.properties">
        </properties>
          <!-- 配置运行环境 -->
          <!-- default 表示默认使用哪一个环境,可以配置多个,比如开发时的测试环境,上线后的正式环境等 -->
          <environments default="mysqlEM">
            <environment id="mysqlEM">
                <transactionManager type="JDBC">
                </transactionManager>
                <environment type="POOLED">
                    <property name="driver" value="${jdbc.driver}"/>
                    <property name="url" value="${jdbc.url}"/>
                    <property name="username" value="${jdbc.user}"/>
                    <property name="password" value="${jdbc.password}"/>
                </dataSource>
            </environment>
          </environments>
          <!-- 注册映射文件 -->
          <mappers>
              <mapper resource="mapper/mapper.xml"/>
            <mapper resource="mapper/mapper1.xml"/>
          </mappers>
  </configuration>

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

Mybatis【2.3】-- Mybatis一定要使用commit才能成功修改数据么?

代码直接放在Github仓库【https://github.com/Damaer/Myb...】,mybatis-02可直接运行,就不占篇幅了。

为什么我们有时候不使用commit也能修改数据库成功?

[TOC]

1.从数据库的层面上来讲,其实这个主要看你用什么“存储引擎”

像以下的代码就是使用了自动提交的mysql引擎。

CREATE TABLE `student` ( `id` INT NOT NULL AUTO_INCREMENT , `name` VARCHAR(20) NOT NULL , 
`age` INT NOT NULL , `score` DOUBLE NOT NULL , PRIMARY KEY (`id`)) ENGINE = MyISAM; 

如果是不支持事务的引擎,如myisam,则是否commit都没有效的。
如果是支持事务的引擎,如innodb,则有系统参数设置是否自动commit,查看参数如下:

mysql> show variables like '%autocommit%';
+---------------+-------+
| Variable_name | Value |
+---------------+-------+
| autocommit    | ON    |
+---------------+-------+
1 row in set (0.00 sec)
mysql>

显示结果为on表示事务自动提交,不用手工去commit,当然,你可以设置其为OFF,然后自己手工去commit。

2.使用myIsam引擎,不需要commit

比如下面的代码:

public class StudentDaoImpl implements IStudentDao {
    private SqlSession sqlSession;
    public void insertStu(Student student) {
        try {
            InputStream inputStream;
            inputStream = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession=sqlSessionFactory.openSession();
            sqlSession.insert("insertStudent",student);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

我们可以看到已经更新了一行,我们完全不使用commit

3.创建数据表(使用Innodb),也不提交,结果没有插入

CREATE TABLE `student` ( `id` INT NOT NULL AUTO_INCREMENT , `name` VARCHAR(20) NOT NULL , 
`age` INT NOT NULL , `score` DOUBLE NOT NULL , PRIMARY KEY (`id`)) ENGINE = Innodb; 

我们再执行插入时,发现控制台输出是这样的:

好像输入也成功了,但是我去数据库看了一下,居然是空的:

那我们将代码换成这样,加入提交事务:

public class StudentDaoImpl implements IStudentDao {
    private SqlSession sqlSession;
    public void insertStu(Student student) {
        try {
            InputStream inputStream;
            inputStream = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession=sqlSessionFactory.openSession();
            sqlSession.insert("insertStudent",student);
            // 提交事务
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(sqlSession!=null){
                sqlSession.close();
            }
        }
    }
}

执行代码,我们会发现事务提交成功了,同时我们也关闭数据库了:

打开数据库,我们会发现,居然没有id为1的记录,为什么直接跳到2了呢?还记不记得之前插入一次但是没有提交,所以问题就在这里。上一次的提交已经写到事务里面了,只是没有提交,所以这一次提交的时候,上一次默认已经占用了那条记录,只是不写进数据库中。有提交就可以回滚,所以要使用回滚的话,可以使用sqlsession.rollback()

如果我们使用sqlsession.close()的话,我们就不需要使用回滚了。
下面是我把commit去掉,但是留下close的结果,我们可以看到没有commit,但是已经会自动rollback了,所以只要使用sqlsession.close()就会自动回滚再关闭。

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

Mybatis【2.2】-- Mybatis关于创建SqlSession源码分析的几点疑问?

代码直接放在Github仓库【https://github.com/Damaer/Myb... 】,可直接运行,就不占篇幅了。

[TOC]

1.为什么我们使用SQLSessionFactoryBuilder的时候不需要自己关闭流?

我们看我们的代码:

public class StudentDaoImpl implements IStudentDao {
    private SqlSession sqlSession;
    public void insertStu(Student student) {
        try {
            InputStream inputStream;
            inputStream = Resources.getResourceAsStream("mybatis.xml");
            SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
            sqlSession=sqlSessionFactory.openSession();
            sqlSession.insert("insertStudent",student);
            sqlSession.commit();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(sqlSession!=null){
                sqlSession.close();
            }
        }
    }
}

当我们使用inputStream = Resources.getResourceAsStream("mybatis.xml");的时候,我们并需要去关闭inputstream,我们可以查看源码,首先看到SqlSessionFactoryBuilder().build()这个方法:

    // 将inputstream传递进去,调用了另一个分装的build()方法
    public SqlSessionFactory build(InputStream inputStream) {
        return this.build((InputStream)inputStream, (String)null, (Properties)null);
    }

跟进去,我们再来看另一个build方法,里面有一个finally模块,无论怎么样都会执行close方法,所以这就是为什么我们在使用的时候为什么不用关闭inputstream的原因:因为这个流是在finally代码块中被关闭了。

    public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties) {
        SqlSessionFactory var5;
        try {
            XMLConfigBuilder parser = new XMLConfigBuilder(inputStream, environment, properties);
            var5 = this.build(parser.parse());
        } catch (Exception var14) {
            throw ExceptionFactory.wrapException("Error building SqlSession.", var14);
        } finally {
            ErrorContext.instance().reset();
            try {
                // 关闭流
                inputStream.close();
            } catch (IOException var13) {
                ;
            }

        }
        return var5;
    }

2. Sqlsession是如何创建的?

语句里面执行代码:使用SQLSessionFactory去打开一个session,这里的session我们可以初步理解为一个sql的会话,类似我们想要发信息给别人,肯定需要打开一个和别人的会话。

sqlSession=sqlSessionFactory.openSession();

我们需要查看源码,我们发现opensession是sqlSessionFactory的一个接口方法,sqlSessionFactory是一个接口。

public interface SqlSessionFactory {
    // 在这里只贴出了一个方法,其他的就不贴了
    SqlSession openSession();
    }

idea选中该方法,ctrl + alt +B,我们可以发现有DefaultSqlSessionFactory,和SqlSessionManager这两个类实现了SqlSessionFactory这个接口

那么我们需要跟进去DefaultSqlSessionFactory这个类的openSesseion方法,在里面调用了一个封装好的方法:openSessionFromDataSource()

    public SqlSession openSession() {
        return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), (TransactionIsolationLevel)null, false);
    }

当然在DefaultSqlSessionFactory这个类里面还有一个方法,参数是autoCommit,也就是可以指定是否自动提交:

    public SqlSession openSession(boolean autoCommit) {
        return this.openSessionFromDataSource(this.configuration.getDefaultExecutorType(), (TransactionIsolationLevel)null, autoCommit);
    }

我们再跟进去源码,我们会发现有一个参数是autoCommit,也就是自动提交,我们可以看到上一步传值是false,也就是不会自动提交,通过configuration(主配置)获取environment(运行环境),然后通过environment(环境)开启和获取一个事务工厂,通过事务工厂获取事务对象Transaction,通过事务对象创建一个执行器executor,Executor是一个接口,实现类有比如SimpleExecutor,BatchExecutor,ReuseExecutor,所以我们下面代码里的execType,是指定它的类型,生成指定类型的Executor,把引用给接口对象,有了执行器之后就可以return一个DefaultSqlSession对象了。

    private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
        Transaction tx = null;
        DefaultSqlSession var8;
        try {
            // configuration是主配置文件
            Environment environment = this.configuration.getEnvironment();
            // 获取事务工厂,事务管理器可以使jdbc之类的
            TransactionFactory transactionFactory = this.getTransactionFactoryFromEnvironment(environment);
            // 获取事务对象Transaction
            tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
            // 通过事务对象创建一个执行器executor
            Executor executor = this.configuration.newExecutor(tx, execType);
            // DefaultSqlSession是SqlSession实现类,创建一个DefaultSqlSession并返回
            var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);
        } catch (Exception var12) {
            this.closeTransaction(tx);
            throw ExceptionFactory.wrapException("Error opening session.  Cause: " + var12, var12);
        } finally {
            ErrorContext.instance().reset();
        }
        return var8;
    }

我们跟 var8 = new DefaultSqlSession(this.configuration, executor, autoCommit);这句代码,我们这是初始化函数赋值于各个成员变量,我们发现里面有一个dirty成员,这是干什么用的呢?从名字上来讲我们理解是脏的,这里既然设置为false,那就是不脏的意思。那到底什么是脏呢?脏是指内存里面的数据与数据库里面的数据存在不一致的问题,如果一致就是不脏的
后面会解释这个dirty的作用之处,到这里一个SqlSession就创建完成了。

    public DefaultSqlSession(Configuration configuration, Executor executor, boolean autoCommit) {
        this.configuration = configuration;
        this.executor = executor;
        this.dirty = false;
        this.autoCommit = autoCommit;
    }

3.增删改是怎么执行的

我们使用到这句代码:

sqlSession.insert("insertStudent",student);

我们发现同样是接口方法,上面我们知道SqlSession其实是DefaultSqlSession所实现的接口,那么我们跟进去DefaultSqlSession的insert()方法,我们发现其实inset方法底层也是实现了update这个方法,同样的delete方法在底层也是调用了update这个方法,增,删,改本质上都是改

public int insert(String statement, Object parameter) {
    return this.update(statement, parameter);
}
public int update(String statement) {
    return this.update(statement, (Object)null);
}

那么我们现在跟进去update方法中,dirty变成ture,表明即将改数据,所以数据库数据与内存中数据不一致了,statement是我们穿过来的id,这样就可以通过id拿到statement的对象,然后就通过执行器执行修改的操作:

    public int update(String statement, Object parameter) {
        int var4;
        try {
            // dirty变成ture,表明数据和数据库数据不一致,需要更新
            this.dirty = true;
            // 通过statement的id把statement从配置中拿到映射关系
            MappedStatement ms = this.configuration.getMappedStatement(statement);
            // 执行器执行修改的操作
            var4 = this.executor.update(ms, this.wrapCollection(parameter));
        } catch (Exception var8) {
            throw ExceptionFactory.wrapException("Error updating database.  Cause: " + var8, var8);
        } finally {
            ErrorContext.instance().reset();
        }
        return var4;
    }

4.SqlSession.commit()为什么可以提交事务(transaction)?

首先,我们使用到的源码,同样选择DefaultSqlSession这个接口的方法,我们发现commit里面调用了另一个commit方法,传进去一个false的值:

    public void commit() {
        this.commit(false);
    }

我们跟进去,发现上面传进去的false是变量force,里面调用了一个isCommitOrRollbackRequired(force)方法,执行的结果返回给commit方法当参数。

public void commit(boolean force) {
    try {
        this.executor.commit(this.isCommitOrRollbackRequired(force));
        // 提交之后dirty置为false,因为数据库与内存的数据一致了。
        this.dirty = false;
    } catch (Exception var6) {
        throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + var6, var6);
    } finally {
        ErrorContext.instance().reset();
    }
}

我们跟进去isCommitOrRollbackRequired(force)这个方法,这个方法从命名上是需要提交还是回滚的意思。在前面我们知道autoCommit是false,那么取反之后就是true,关于dirty我们知道前面我们执行过insert()方法,insert的底层调用了update方法,将dirty置为true,表示即将修改数据,那我们知道!this.autoCommit && this.dirty的值就是true,那么就短路了,所以整个表达式的值就是true。

private boolean isCommitOrRollbackRequired(boolean force) {
    return !this.autoCommit && this.dirty || force;
}

返回上一层的,我们知道this.isCommitOrRollbackRequired(force)的返回值是true。

this.executor.commit(this.isCommitOrRollbackRequired(force));

跟进去commit方法,这个commit方法是一个接口方法,实现接口的有BaseExecutor,还有CachingExecutor,我们选择BaseExecutor这个接口实现类:

// required是true
public void commit(boolean required) throws SQLException {
    // 如果已经 关闭,那么就没有办法提交,抛出异常
    if (this.closed) {
        throw new ExecutorException("Cannot commit, transaction is already closed");
    } else {
        this.clearLocalCache();
        this.flushStatements();
        // 如果required是true,那么就提交事务
        if (required) {
            this.transaction.commit();
        }
    }
}

5.为什么sqlsession关闭就不需要回滚了?

假如我们在上面已经提交过了,那么dirty的值就为false。我们使用的是sqlSession.close();,跟进去源码,同样是接口,我们跟DefaoultSqlsession的方法,同样调用了isCommitOrRollbackRequired()这个方法:

    public void close() {
        try {
            this.executor.close(this.isCommitOrRollbackRequired(false));
            this.dirty = false;
        } finally {
            ErrorContext.instance().reset();
        }
    }

我们跟进去isCommitOrRollbackRequired(false)这个方法,我们知道force传进来的值是false,autoCommit是false(只要我们使用无参的sqlSessionFactory.openSession();),取反之后!autoCommit是true,但是dirty已经是false,所以!this.autoCommit && this.dirty的值是false,那么force也是false,所以整一个表达式就是false:

    private boolean isCommitOrRollbackRequired(boolean force) {
        return !this.autoCommit && this.dirty || force;
    }

我们返回上一层,executor.close()方法,参数是false:

this.executor.close(this.isCommitOrRollbackRequired(false));

跟进去close()方法,forceRollback的值是false,我们发现有一个this.rollback(forceRollback)

public void close(boolean forceRollback) {
        try {
            try {
                this.rollback(forceRollback);
            } finally {
                // 最后如果事务不为空,那么我们就关闭事务
                if (this.transaction != null) {
                    this.transaction.close();
                }
            }
        } catch (SQLException var11) {
            log.warn("Unexpected exception on closing transaction.  Cause: " + var11);
        } finally {
            this.transaction = null;
            this.deferredLoads = null;
            this.localCache = null;
            this.localOutputParameterCache = null;
            this.closed = true;
        }
    }

我们跟进去rollback()这个方法,我们可以发现required是fasle,所以 this.transaction.rollback();是不会执行的,这个因为我们在前面做了提交了,所以是不用回滚的:

     public void rollback(boolean required) throws SQLException {
        if (!this.closed) {
            try {
                this.clearLocalCache();
                this.flushStatements(true);
            } finally {
                if (required) {
                    this.transaction.rollback();
                }

            }
        }

    }

假如我们现在执行完insert()方法,但是没有使用commit(),那么现在的dirty就是true,也就是数据库数据与内存的数据不一致。我们再执行close()方法的时候,dirty是true,!this.autoCommit是true,那么整个表达式就是true。

    private boolean isCommitOrRollbackRequired(boolean force) {
        return !this.autoCommit && this.dirty || force;
    }

返回上一层,close的参数就会变成true

this.executor.close(this.isCommitOrRollbackRequired(false));

close()方法里面调用了 this.rollback(forceRollback);,参数为true,我们跟进去,可以看到确实执行了回滚:

     public void rollback(boolean required) throws SQLException {
        if (!this.closed) {
            try {
                this.clearLocalCache();
                this.flushStatements(true);
            } finally {
                if (required) {
                    this.transaction.rollback();
                }

            }
        }

    }

所以只要我们执行了提交(commit),那么关闭的时候就不会执行回滚,只要没有提交事务,就会发生回滚,所以里面的dirty是很重要的。

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

Java反射说得透彻一些

[TOC]

很多时候我们会遇到别人问一个问题:你给我讲一下反射,到底是什么东西?怎么实现的?我们能用反射来做什么?它有什么优缺点?下面我们会围绕着这几个问题展开:

一、反射机制是什么?

反射是什么?什么是反?什么是正射?
有反就有正,我们知道正常情况, 如果我们希望创建一个对象,会使用以下的语句:

Person person = new Person();

其实我们第一次执行上面的语句的时候,JVM会先加载Person.class,加载到内存完之后,在方法区/堆中会创建了一个Class对象,对应这个Person类。这里有争议,有人说是在方法区,有些人说是在堆。个人感觉应该JVM规范说是在方法区,但是不是强制要求,而且不同版本的JVM实现也不一样。具体参考以下链接,这里不做解释:
https://www.cnblogs.com/xy-nb...
而上面正常的初始化对象的方法,也可以说是“正射”,就是使用Class对象创建出一个Person对象。

而反射则相反,是根据Person对象,获取到Class对象,然后可以获取到Person类的相关信息,进行初始化或者调用等一系列操作。

运行状态时,可以构造任何一个类的对象,获取到任意一个对象所属的类信息,以及这个类的成员变量或者方法,可以调用任意一个对象的属性或者方法。可以理解为具备了 动态加载对象 以及 对对象的基本信息进行剖析和使用 的能力。

提供的功能包括:

  • 1.在运行时判断一个对象所属的类
  • 2.在运行时构造任意一个类的对象
  • 3.在运行时获取一个类定义的成员变量以及方法
  • 4.在运行时调用任意一个对象的方法
  • 5.生成动态代理

灵活,强大,可以在运行时装配,无需在组件之间进行源代码链接,但是使用不当效率会有影响。所有类的对象都是Class的实例。
既然我们可以对类的全限定名,方法以及参数等进行配置,完成对象的初始化,那就是相当于增加了java的可配置性。

这里特别需要明确的一点:类本身也是一个对象,方法也是一个对象,在Java里面万物皆可对象,除了基础数据类型...

二、反射的具体使用

2.1 获取对象的包名以及类名

package invocation;
public class MyInvocation {
    public static void main(String[] args) {
        getClassNameTest();
    }
    
    public static void getClassNameTest(){
        MyInvocation myInvocation = new MyInvocation();
        System.out.println("class: " + myInvocation.getClass());
        System.out.println("simpleName: " + myInvocation.getClass().getSimpleName());
        System.out.println("name: " + myInvocation.getClass().getName());
        System.out.println("package: " +
                "" + myInvocation.getClass().getPackage());
    }
}

运行结果:

class: class invocation.MyInvocation
simpleName: MyInvocation
name: invocation.MyInvocation
package: package invocation

由上面结果我们可以看到:
1.getClass():打印会带着class+全类名
2.getClass().getSimpleName():只会打印出类名
3.getName():会打印全类名
4.getClass().getPackage():打印出package+包名

getClass()获取到的是一个对象,getPackage()也是。

2.2 获取Class对象

在java中,一切皆对象。java中可以分为两种对象,实例对象和Class对象。这里我们说的获取Class对象,其实就是第二种,Class对象代表的是每个类在运行时的类型信息,指和类相关的信息。比如有一个Student类,我们用Student student = new Student()new一个对象出来,这个时候Student这个类的信息其实就是存放在一个对象中,这个对象就是Class类的对象,而student这个实例对象也会和Class对象关联起来。
我们有三种方式可以获取一个类在运行时的Class对象,分别是

  • Class.forName("com.Student")
  • student.getClass()
  • Student.class

实例代码如下:

package invocation;

public class MyInvocation {
    public static void main(String[] args) {
        getClassTest();
    }
    public static void getClassTest(){
        Class<?> invocation1 = null;
        Class<?> invocation2 = null;
        Class<?> invocation3 = null;
        try {
            // 最常用的方法
            invocation1 = Class.forName("invocation.MyInvocation");
        }catch (Exception ex){
            ex.printStackTrace();
        }
        invocation2 = new MyInvocation().getClass();
        invocation3 = MyInvocation.class;
        System.out.println(invocation1);
        System.out.println(invocation2);
        System.out.println(invocation3);
    }
}

执行的结果如下,三个结果一样:

class invocation.MyInvocation
class invocation.MyInvocation
class invocation.MyInvocation

2.3 getInstance()获取指定类型的实例化对象

首先我们有一个Student类,后面都会沿用这个类,将不再重复。

class Student{
    private int age;

    private String name;

    public Student() {
    }
    public Student(int age) {
        this.age = age;
    }

    public Student(String name) {
        this.name = name;
    }
    
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }

我们可以使用getInstance()方法构造出一个Student的对象:

    public static void getInstanceTest() {
        try {
            Class<?> stduentInvocation = Class.forName("invocation.Student");
            Student student = (Student) stduentInvocation.newInstance();
            student.setAge(9);
            student.setName("Hahs");
            System.out.println(student);

        }catch (Exception ex){
            ex.printStackTrace();
        }
    }
    
    
输出结果如下:
Student{age=9, name='Hahs'}

但是如果我们取消不写Student的无参构造方法呢?就会出现下面的报错:

java.lang.InstantiationException: invocation.Student
    at java.lang.Class.newInstance(Class.java:427)
    at invocation.MyInvocation.getInstanceTest(MyInvocation.java:40)
    at invocation.MyInvocation.main(MyInvocation.java:8)
Caused by: java.lang.NoSuchMethodException: invocation.Student.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.newInstance(Class.java:412)
    ... 2 more

这是因为我们重写了构造方法,而且是有参构造方法,如果不写构造方法,那么每个类都会默认有无参构造方法,重写了就不会有无参构造方法了,所以我们调用newInstance()的时候,会报没有这个方法的错误。值得注意的是,newInstance()是一个无参构造方法。

2.4 通过构造函数对象实例化对象

除了newInstance()方法之外,其实我们还可以通过构造函数对象获取实例化对象,怎么理解?这里只构造函数对象,而不是构造函数,也就是构造函数其实就是一个对象,我们先获取构造函数对象,当然也可以使用来实例化对象。

可以先获取一个类的所有的构造方法,然后遍历输出:

    public static void testConstruct(){
        try {
            Class<?> stduentInvocation = Class.forName("invocation.Student");
            Constructor<?> cons[] = stduentInvocation.getConstructors();
            for(int i=0;i<cons.length;i++){
                System.out.println(cons[i]);
            }

        }catch (Exception ex){
            ex.printStackTrace();
        }
    }

输出结果:

public invocation.Student(int,java.lang.String)
public invocation.Student(java.lang.String)
public invocation.Student(int)
public invocation.Student()

取出一个构造函数我们可以获取到它的各种信息,包括参数,参数个数,类型等等:

    public static void constructGetInstance() {
        try {
            Class<?> stduentInvocation = Class.forName("invocation.Student");
            Constructor<?> cons[] = stduentInvocation.getConstructors();
            Constructor constructors = cons[0];
            System.out.println("name: " + constructors.getName());
            System.out.println("modifier: " + constructors.getModifiers());
            System.out.println("parameterCount: " + constructors.getParameterCount());
            System.out.println("构造参数类型如下:");
            for (int i = 0; i < constructors.getParameterTypes().length; i++) {
                System.out.println(constructors.getParameterTypes()[i].getName());
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

输出结果,modifier是权限修饰符,1表示为public,我们可以知道获取到的构造函数是两个参数的,第一个是int,第二个是String类型,看来获取出来的顺序并不一定是我们书写代码的顺序。

name: invocation.Student
modifier: 1
parameterCount: 2
构造参数类型如下:
int
java.lang.String

既然我们可以获取到构造方法这个对象了,那么我们可不可以通过它去构造一个对象呢?答案肯定是可以!!!
下面我们用不同的构造函数来创建对象:

    public static void constructGetInstanceTest() {
        try {
            Class<?> stduentInvocation = Class.forName("invocation.Student");
            Constructor<?> cons[] = stduentInvocation.getConstructors();
            // 一共定义了4个构造器
            Student student1 = (Student) cons[0].newInstance(9,"Sam");
            Student student2 = (Student) cons[1].newInstance("Sam");
            Student student3 = (Student) cons[2].newInstance(9);
            Student student4 = (Student) cons[3].newInstance();
            System.out.println(student1);
            System.out.println(student2);
            System.out.println(student3);
            System.out.println(student4);

        } catch (Exception ex) {
            ex.printStackTrace();
        }

输出如下:

Student{age=9, name='Sam'}
Student{age=0, name='Sam'}
Student{age=9, name='null'}
Student{age=0, name='null'}

构造器的顺序我们是必须一一针对的,要不会报一下的参数不匹配的错误:

java.lang.IllegalArgumentException: argument type mismatch
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at invocation.MyInvocation.constructGetInstanceTest(MyInvocation.java:85)
    at invocation.MyInvocation.main(MyInvocation.java:8)

2.5 获取类继承的接口

通过反射我们可以获取接口的方法,如果我们知道某个类实现了接口的方法,同样可以做到通过类名创建对象调用到接口的方法。

首先我们定义两个接口,一个InSchool:

public interface InSchool {
    public void attendClasses();
}

一个AtHome:

public interface AtHome {
    public void doHomeWork();
}

创建一个实现两个接口的类Student.java

public class Student implements AtHome, InSchool {
    public void doHomeWork() {
        System.out.println("I am a student,I am doing homework at home");
    }

    public void attendClasses() {
        System.out.println("I am a student,I am attend class in school");
    }
}

测试代码如下:

public class Test {
    public static void main(String[] args) throws Exception {
        Class<?> studentClass = Class.forName("invocation.Student");
        Class<?>[] interfaces = studentClass.getInterfaces();
        for (Class c : interfaces) {
            // 获取接口
            System.out.println(c);
            // 获取接口里面的方法
            Method[] methods = c.getMethods();
            // 遍历接口的方法
            for (Method method : methods) {
                // 通过反射创建对象
                Student student = (Student) studentClass.newInstance();
                // 通过反射调用方法
                method.invoke(student, null);
            }
        }
    }
}

结果如下:

可以看出其实我们可以获取到接口的数组,并且里面的顺序是我们继承的顺序,通过接口的Class对象,我们可以获取到接口的方法,然后通过方法反射调用实现类的方法,因为这是一个无参数的方法,所以只需要传null即可。

2.6 获取父类相关信息

主要是使用getSuperclass()方法获取父类,当然也可以获取父类的方法,执行父类的方法,首先创建一个Animal.java:

public class Animal {
    public void doSomething(){
        System.out.println("animal do something");
    }
}

Dog.java继承于Animal.java

public class Dog extends Animal{
    public void doSomething(){
        System.out.println("Dog do something");
    }
}

我们可以通过反射创建Dog对象,获取其父类Animal以及创建对象,当然也可以获取Animal的默认父类Object

public class Test {
    public static void main(String[] args) throws Exception {
        Class<?> dogClass = Class.forName("invocation02.Dog");
        System.out.println(dogClass);
        invoke(dogClass);

        Class<?> animalClass = dogClass.getSuperclass();
        System.out.println(animalClass);
        invoke(animalClass);

        Class<?> objectClass = animalClass.getSuperclass();
        System.out.println(objectClass);
        invoke(objectClass);
    }

    public static void invoke(Class<?> myClass) throws Exception {
        Method[] methods = myClass.getMethods();
        // 遍历接口的方法
        for (Method method : methods) {
            if (method.getName().equalsIgnoreCase("doSomething")) {
                // 通过反射调用方法
                method.invoke(myClass.newInstance(), null);
            }
        }
    }
}

输入如下:

2.7 获取当前类的公有属性和私有属性以及更新

创建一个Person.java,里面有静态变量,非静态变量,以及publicprotected,private不同修饰的属性。

public class Person {

    public static String type ;

    private static String subType ;

    // 名字(公开)
    public String name;

    protected String gender;

    private String address;

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

使用getFields()可以获取到public的属性,包括static属性,使用getDeclaredFields()可以获取所有声明的属性,不管是publicprotected,private不同修饰的属性。

修改public属性,只需要field.set(object,value)即可,但是private属性不能直接set,否则会报以下的错误。

Exception in thread "main" java.lang.IllegalAccessException: Class invocation03.Tests can not access a member of class invocation03.Person with modifiers "private"
    at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
    at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
    at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
    at java.lang.reflect.Field.set(Field.java:761)
    at invocation03.Tests.main(Tests.java:21)

那么需要怎么做呢?private默认是不允许外界操作其值的,这里我们可以使用field.setAccessible(true);,相当于打开了操作的权限。

那static的属性修改和非static的一样,但是我们怎么获取呢?
如果是public修饰的,可以直接用类名获取到,如果是private修饰的,那么需要使用filed.get(object),这个方法其实对上面说的所有的属性都可以的。
测试代码如下

public class Tests {
    public static void main(String[] args) throws Exception{
        Class<?> personClass = Class.forName("invocation03.Person");
        Field[] fields = personClass.getFields();
        // 获取公开的属性
        for(Field field:fields){
            System.out.println(field);
        }
        System.out.println("=================");
        // 获取所有声明的属性
        Field[] declaredFields = personClass.getDeclaredFields();
        for(Field field:declaredFields){
            System.out.println(field);
        }
        System.out.println("=================");
        Person person = (Person) personClass.newInstance();
        person.name = "Sam";
        System.out.println(person);

        // 修改public属性
        Field fieldName = personClass.getDeclaredField("name");
        fieldName.set(person,"Jone");

        // 修改private属性
        Field addressName = personClass.getDeclaredField("address");
        // 需要修改权限
        addressName.setAccessible(true);
        addressName.set(person,"东风路47号");
        System.out.println(person);

        // 修改static 静态public属性
        Field typeName = personClass.getDeclaredField("type");
        typeName.set(person,"人类");
        System.out.println(Person.type);

        // 修改静态 private属性
        Field subType = personClass.getDeclaredField("subType");
        subType.setAccessible(true);
        subType.set(person,"黄种人");
        System.out.println(subType.get(person));
    }
}

结果:

从结果可以看出,不管是public,还是protectedprivate修饰的,我们都可以通过反射对其进行查询和修改,不管是静态变量还是非静态变量。
getDeclaredField()可以获取到所有声明的属性,而getFields()则只能获取到public的属性。对于非public的属性,我们需要修改其权限才能访问和修改:field.setAccessible(true)

获取属性值需要使用field.get(object),值得注意的是:每个属性,其本身就是对象

2.8 获取以及调用类的公有/私有方法

既然可以获取到公有属性和私有属性,那么我想,执行公有方法和私有方法应该都不是什么问题?

那下面我们一起来学习一下...

先定义一个类,包含各种修饰符,以及是否包含参数,是否为静态方法,Person.java:

public class Person {
    // 非静态公有无参数
    public void read(){
        System.out.println("reading...");
    }

    // 非静态公有无参数有返回
    public String getName(){
        return "Sam";
    }

    // 非静态公有带参数   
    public int readABookPercent(String name){
        System.out.println("read "+name);
        return 80;
    }

    // 私有有返回值
    private String getAddress(){
        return "东方路";
    }

    // 公有静态无参数无返回值
    public static void staticMethod(){
        System.out.println("static public method");
    }

    // 公有静态有参数
    public static void staticMethodWithArgs(String args){
        System.out.println("static public method:"+args);
    }

    // 私有静态方法
    private static void staticPrivateMethod(){
        System.out.println("static private method");
    }
}

首先我们来看看获取里面所有的方法:

public class Tests {
    public static void main(String[] args) throws Exception {
        Class<?> personClass = Class.forName("invocation03.Person");
        Method[] methods = personClass.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }

        System.out.println("=============================================");
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method method : declaredMethods) {
            System.out.println(method);
        }
    }
}

结果如下:

咦,我们发现getMethods()确实可以获取所有的公有的方法,但是有一个问题,就是他会把父类的也获取到,也就是上面图片绿色框里面的,我们知道所有的类默认都继承了Object类,所以它把Object的那些方法都获取到了。
getDeclaredMethods确实可以获取到公有和私有的方法,不管是静态还是非静态,但是它是获取不到父类的方法的。

那如果我们想调用方法呢?先试试调用非静态方法:

public class Tests {
    public static void main(String[] args) throws Exception {
        Class<?> personClass = Class.forName("invocation03.Person");
        Person person = (Person) personClass.newInstance();
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method method : declaredMethods) {
            if(method.getName().equalsIgnoreCase("read")){
                method.invoke(person,null);
                System.out.println("===================");
            }else if(method.getName().equalsIgnoreCase("getName")){
                System.out.println(method.invoke(person,null));
                System.out.println("===================");
            }else if(method.getName().equalsIgnoreCase("readABookPercent")){
                System.out.println(method.invoke(person,"Sam"));
                System.out.println("===================");
            }
        }

    }
}

结果如下,可以看出method.invoke(person,null);是调用无参数的方法,而method.invoke(person,"Sam")则是调用有参数的方法,要是有更多参数,也只需要在里面多加一个参数即可,返回值也同样可以获取到。

那么private方法呢?我们照着来试试,试试就试试,who 怕 who?

public class Tests {
    public static void main(String[] args) throws Exception {
        Class<?> personClass = Class.forName("invocation03.Person");
        Person person = (Person) personClass.newInstance();
        Method[] declaredMethods = personClass.getDeclaredMethods();
        for (Method method : declaredMethods) {
            if(method.getName().equalsIgnoreCase("getAddress")){
                method.invoke(person,null);
            }
        }

    }
}

结果报错了:

Exception in thread "main" java.lang.IllegalAccessException: Class invocation03.Tests can not access a member of class invocation03.Person with modifiers "private"
    at sun.reflect.Reflection.ensureMemberAccess(Reflection.java:102)
    at java.lang.reflect.AccessibleObject.slowCheckMemberAccess(AccessibleObject.java:296)
    at java.lang.reflect.AccessibleObject.checkAccess(AccessibleObject.java:288)
    at java.lang.reflect.Method.invoke(Method.java:491)
    at invocation03.Tests.main(Tests.java:13)

一看就是没有权限,小场面,不要慌,我来操作一波,只要加上

method.setAccessible(true);

哦豁,完美解决了...

那么问题来了,上面说的都是非静态的,我就想要调用静态的方法。
当然用上面的方法,对象也可以直接调用到类的方法的:

一点问题都没有,为什么输出结果有几个null,那是因为这函数是无返回值的呀,笨蛋...

如果我不想用遍历方法的方式,再去判断怎么办?能不能直接获取到我想要的方法啊?那答案肯定是可以啊。

public class Tests {
    public static void main(String[] args) throws Exception {
        Class<?> personClass = Class.forName("invocation03.Person");
        Person person = (Person) personClass.newInstance();
        Method method = personClass.getMethod("readABookPercent", String.class);
        method.invoke(person, "唐诗三百首");
    }
}

结果和上面调用的完全一样,图我就不放了,就一行字。要是这个方法没有参数呢?那就给一个null就可以啦。或者不给也可以。

public class Tests {
    public static void main(String[] args) throws Exception {
        Class<?> personClass = Class.forName("invocation03.Person");
        Person person = (Person) personClass.newInstance();
        Method method = personClass.getMethod("getName",null);
        System.out.println(method.invoke(person));
    }
}

三、反射的优缺点

3.1 优点

反射可以在不知道会运行哪一个类的情况下,获取到类的信息,创建对象以及操作对象。这其实很方便于拓展,所以反射会是框架设计的灵魂,因为框架在设计的时候,为了降低耦合度,肯定是需要考虑拓展等功能的,不能将类型写死,硬编码。

降低耦合度,变得很灵活,在运行时去确定类型,绑定对象,体现了多态功能。

3.2 缺点

这么好用,没有缺点?怎么可能!!!有利就有弊,事物都是有双面性的。
即使功能很强大,但是反射是需要动态类型的,JVM没有办法优化这部分代码,执行效率相对直接初始化对象较低。一般业务代码不建议使用。

反射可以修改权限,比如上面访问到private这些方法和属性,这是会破坏封装性的,有安全隐患,有时候,还会破坏单例的设计。

反射会使代码变得复杂,不容易维护,毕竟代码还是要先写给人看的嘛,逃~

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

技术之路不在一时,山高水长,纵使缓慢,驰而不息。

公众号:「秦怀杂货店」

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

transient关键字的作用以及几个疑问的解决

[TOC]

1.从Serilizable说到transient

我们知道,如果一个对象需要序列化,那么需要实现Serilizable接口,那么这个类的所有非静态属性,都会被序列化。

注意:上面说的是非静态属性,因为静态属性是属于类的,而不是属于类对象的,而序列化是针对类对象的操作,所以这个根本不会序列化。下面我们可以实验一下:
实体类Teacher.class:

import java.io.Serializable;

class Teacher implements Serializable {
    public int age;
    public static String SchoolName;

    public Teacher(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                '}';
    }
}

测试代码SerialTest.java,基本思路就是初始化的时候,静态属性SchoolName为"东方小学",序列化对象之后,将静态属性修改,然后,反序列化,发现其实静态变量还是修改之后的,说明静态变量并没有被序列化。

import java.io.*;

public class SerialTest {
    public static void main(String[] args) {
        Teacher.SchoolName = "东方小学";
        serial();
        Teacher.SchoolName = "西方小学";
        deserial();
        System.out.println(Teacher.SchoolName);
    }
    // 序列化
    private static void serial(){
        try {
            Teacher teacher = new Teacher(9);
            FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(teacher);
            objectOutputStream.flush();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }
    // 反序列化
    private static void deserial() {
        try {
            FileInputStream fis = new FileInputStream("Teacher.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Teacher teacher = (Teacher) ois.readObject();
            ois.close();
            System.out.println(teacher.toString());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出的结果,证明静态变量没有被序列化!!!

Teacher{age=9}
西方小学

2.序列化属性对象的类需要实现Serilizable接口?

突然想到一个问题,如果有些属性是对象,而不是基本类型,需不需要改属性的类型也实现Serilizable呢?

问题的答案是:需要!!!

下面是实验过程:

首先,有一个Teacher.java,实现了Serializable,里面有一个属性是School类型:

import java.io.Serializable;

class Teacher implements Serializable {
    public int age;

    public School school;
    public Teacher(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                '}';
    }
}

School类型,不实现Serializable:


public class School {
    public String name;

    public School(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                '}';
    }
}

测试代码,我们只测试序列化:

import java.io.*;

public class SerialTest {
    public static void main(String[] args) {
        serial();
    }

    private static void serial(){
        try {
            Teacher teacher = new Teacher(9);
            teacher.school = new School("东方小学");
            FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(teacher);
            objectOutputStream.flush();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

}

会发现报错了,报错的原因是:School不能被序列化,也就是没有实现序列化接口,所以如果我们想序列化一个对象,那么这个对象的属性也必须是可序列化的,或者它是transient修饰的。

java.io.NotSerializableException: com.aphysia.transienttest.School
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1184)
    at java.io.ObjectOutputStream.defaultWriteFields(ObjectOutputStream.java:1548)
    at java.io.ObjectOutputStream.writeSerialData(ObjectOutputStream.java:1509)
    at java.io.ObjectOutputStream.writeOrdinaryObject(ObjectOutputStream.java:1432)
    at java.io.ObjectOutputStream.writeObject0(ObjectOutputStream.java:1178)
    at java.io.ObjectOutputStream.writeObject(ObjectOutputStream.java:348)
    at com.aphysia.transienttest.SerialTest.serial(SerialTest.java:18)
    at com.aphysia.transienttest.SerialTest.main(SerialTest.java:9)

当我们将School实现序列化接口的时候,发现一切就正常了...问题完美解决

3.不想被序列化的字段怎么办?

但是如果有一个变量不是静态变量,但是我们也不想序列化它,因为它可能是一些密码等敏感的字段,或者它是不那么重要的字段,我们不希望增加报文大小,所以想在序列化报文中排除该字段。或者改字段存的是引用地址,不是真正重要的数据,比如ArrayList里面的elementData

这个时候就需要使用transient 关键字,将改字段屏蔽。

当我们用transient修饰School的时候:

import java.io.Serializable;

class Teacher implements Serializable {
    public int age;

    public transient School school;
    public Teacher(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Teacher{" +
                "age=" + age +
                ", school=" + school +
                '}';
    }
}
import java.io.Serializable;

public class School implements Serializable {
    public String name;

    public School(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "School{" +
                "name='" + name + '\'' +
                '}';
    }
}

执行下面序列化和反序列化的代码:

import java.io.*;

public class SerialTest {
    public static void main(String[] args) {
        serial();
        deserial();
    }

    private static void serial(){
        try {
            Teacher teacher = new Teacher(9);
            teacher.school = new School("东方小学");
            FileOutputStream fileOutputStream = new FileOutputStream("Teacher.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(teacher);
            objectOutputStream.flush();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    private static void deserial() {
        try {
            FileInputStream fis = new FileInputStream("Teacher.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Teacher teacher = (Teacher) ois.readObject();
            ois.close();
            System.out.println(teacher.toString());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

执行结果如下,可以看到teacher字段反序列化出来,其实是null,这也是transient起作用了。
但是注意,transient只能修饰变量,但是不能修饰类和方法,

4.ArrayList里面的elementData都被transient 关键字修饰了,为什么ArrayList还可以序列化呢?

这里提一下,既然transient修饰了ArrayList的数据节点,那么为什么序列化的时候我们还是可以看到ArrayList的数据节点呢?
这是因为序列化的时候:

如果仅仅实现了Serializable接口,那么序列化的时候,肯定是调用java.io.ObjectOutputStream.defaultWriteObject()方法,将对象序列化。然后如果是transient修饰了该属性,肯定该属性就不能序列化。
但是,如果我们虽然实现了Serializable接口,也transient修饰了该属性,该属性确实不会在默认的java.io.ObjectOutputStream.defaultWriteObject()方法里面被序列化了,但是我们可以重写一个writeObject()方法,这样一来,序列化的时候调用的就是writeObject(),而不是java.io.ObjectOutputStream.defaultWriteObject()

下面的源码是ObjectInputStream.writeObject(Object obj),里面底层其实会有反射的方式调用到重写的对象的writeObject()方法,这里不做展开。

    public final void writeObject(Object obj) throws IOException {
        // 如果可以被重写,那么就会调用重写的方法
        if (enableOverride) {
            writeObjectOverride(obj);
            return;
        }
        try {
            writeObject0(obj, false);
        } catch (IOException ex) {
            if (depth == 0) {
                writeFatalException(ex);
            }
            throw ex;
        }
    }

ArrayList重写的writeOject()方法如下:

    private void writeObject(java.io.ObjectOutputStream s)
        throws java.io.IOException{
        // Write out element count, and any hidden stuff
        int expectedModCount = modCount;
        // 默认的序列化对象的方法
        s.defaultWriteObject();

        // Write out size as capacity for behavioural compatibility with clone()
        s.writeInt(size);

        // Write out all elements in the proper order.
        for (int i=0; i<size; i++) {
            // 序列化对象的值
            s.writeObject(elementData[i]);
        }

        if (modCount != expectedModCount) {
            throw new ConcurrentModificationException();
        }
    }

我们可以看到,writeOject()里面其实在里面调用了默认的方法defaultWriteObject()defaultWriteObject()底层其实是调用改了writeObject0()ArrayList重写的writeOject()的思路主要是先序列化默认的,然后序列化数组大小,再序列化数组elementData里面真实的元素。这就达到了序列化元素真实内容的目的。

5.除了transient,有没有其他的方式,可以屏蔽反序列化?

且慢,问出这个问题,答案肯定是有的!!!那就是Externalizable接口。

具体情况:Externalizable意思就是,类里面有很多很多属性,但是我只想要一部分,要屏蔽大部分,那么我不想在大部分的属性前面加关键字transient,我只想标识一下自己序列化的字段,这个时候就需要使用Externalizable接口。

show me the code!

首先定义一个Person.java,里面有三个属性

  • age:年龄
  • name:名字(被transient修饰)
  • score:分数

实现了Externalizable接口,就必须实现writeExternal()readExternal()方法。

  • writeExternal:将需要序列化的属性进行自定义序列化
  • readExternal:将需要反序列化的属性进行自定义反序列化
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInput;
import java.io.ObjectOutput;

public class Person implements Externalizable {
    public int age;
    public transient String name;
    public int score;

    // 必须实现无参构造器
    public Person() {
    }

    public Person(int age, String name, int score) {
        this.age = age;
        this.name = name;
        this.score = score;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        /*
         * 指定序列化时候写入的属性。这里不写入score
         */
        out.writeObject(age);
        out.writeObject(name);
        out.writeObject(score);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        /*
         * 指定序列化时候写入的属性。这里仍然不写入年龄
         */
        this.age = (int)in.readObject();
        this.name = (String)in.readObject();
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", score='" + score + '\'' +
                '}';
    }
}

上面的代码,我们可以看出,序列化的时候,将三个属性都写进去了,但是反序列化的时候,我们仅仅还原了两个,那么我们来看看测试的代码:

import java.io.*;

public class ExternalizableTest {
    public static void main(String[] args) {
        serial();
        deserial();
    }

    private static void serial(){
        try {
            Person person = new Person(9,"Sam",98);
            FileOutputStream fileOutputStream = new FileOutputStream("person.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(person);
            objectOutputStream.flush();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }

    private static void deserial() {
        try {
            FileInputStream fis = new FileInputStream("person.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Person person = (Person) ois.readObject();
            ois.close();
            System.out.println(person);
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

测试结果如下,就可以发现其实前面两个都反序列化成功了,后面那个是因为我们重写的时候,没有自定义该属性的反序列化,所以没有是正常的啦...

Person{age=9, name='Sam', score='0'}

如果细心点,可以发现,有一个字段是transient修饰的,不是说修饰了,就不会被序列化么,怎么序列化出来了。

没错,只要实现了Externalizable接口,其实就不会被transient左右了,只会按照我们自定义的字段进行序列化和反序列化,这里的transient是无效的...

关于序列化的transient暂时到这,keep going~

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

技术之路不在一时,山高水长,纵使缓慢,驰而不息。

公众号:秦怀杂货店

查看原文

赞 0 收藏 0 评论 0

秦怀杂货店 发布了文章 · 11月28日

【Java基础】-- native关键字是干什么用的?

[TOC]
今天一不小心跟进Object的源码中,发现一个native关键字,一脸蒙蔽,怎么我从来没有用过。

// 这是计算对象的hsahcode的方法,涉及到内存地址
public native int hashCode();

1.汇编生c,c生万物,其实java要实现对底层的控制,还是需要c/c++帮忙,老大毕竟是老大。

2.native关键字我们开发应用的时候是用不到的,那什么时候用到呢?那些开发java语言的时候用到,native关键字是与c++联合开发的时候使用的,要不java控制不了底层啊,比如内存。所以还是那句:汇编生c,c生万物,c++c的升级版。

3.这是java调用其他地方的接口的一个声明关键字,意思是这个方法不是java实现的,有挺多的编程语言都有这样的特性,比如c++里面使用extern "c"来表示告诉c++编译器去调用c里面已经实现好的函数,而不是自己去实现。native方法有点像java 里面的interface,都不用去实现,而是有别人去实现,但是interface是谁实现接口谁实现,native方法是直接交给c/c++来实现。java只能调用,由操作系统实现。

4.native方法不能与abstract方法一起使用,因为native表示这些方法是有实现体的,但是abstract却表示这些方法是没有实现体的,那么两者矛盾,肯定也不能一起使用。

1.怎么调用到native方法的呢?

上面说native表示这个方法不是java实现的,那么就不是原生态方法,也就不会存在这个文件中,而是存在其他地方,那么java要怎么调用才能调用到呢?

  • JNI(Java Native Interface)这是一个本机编程的接口,它也是java jdk(开发工具包)的一部分,JNI可以支持java中使用其他语言,java要调用其他语言的接口,需要经过他处理。java所谓的跨平台,在一定程度上放弃了底层操作,因为不同的硬件或者操作系统底层的操作都是不一样的。

那么我们现在来写一个程序:helloWorld.java(我的所有写的文件都放在桌面,同个文件夹即可)

public class helloworld{
  static
  {
    System.loadLibrary("cSayHello");
  }
  public static native void hello();
  @SuppressWarnings("static-access")
  public static void main(String[] args){
    new helloworld().hello();
  }
}

直接在编译器运行这段代码会出现下面错误:

上面的错误是说找不到cSayHello:no cSayHello in java.library.path,所以啊,这个c/c++的方法我们要自己实现,毕竟我们用的不是操作系统以及定义好的方法。
所以我们先来,使用cmd 在helloworld.java所在的目录下 使用命令行:

javac helloworld
javah helloworld

然后我们可以看到在helloworld.java所在的目录下多了两个文件,一个是helloworld.class文件,一个是helloworld.h文件。

打开helloworld.h,里面引用了jni.h这个文件,这个文件在我们安装的java目录下面的include文件下:

/* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class helloworld */

#ifndef _Included_helloworld
#define _Included_helloworld
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     helloworld
 * Method:    hello
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_helloworld_hello
  (JNIEnv *, jclass);

#ifdef __cplusplus
}
#endif
#endif

我的java是装在D盘下面:

我们来写需要引入的c文件cSayHello,我也是放在桌面,反正同一个文件夹就可以。

#include "helloworld.h"
#include <stdio.h>
 
JNIEXPORT void JNICALL Java_helloworld_hello(JNIEnv *env, jclass jc)
{
    printf("java helloworld");    
}

windows系统上,需要下载安装WinGW Gcc,安装教程参考https://www.jianshu.com/p/535... 安装成功cmd输入:

gcc -m64  -Wl,--add-stdcall-alias -I"D:\Java\jdk1.8.0_111\include" -I"D:\Java\jdk1.8.0_111\include\win32" -shared -o cSayHello.dll helloworld.c

然后直接运行,就可以看到输出了

java helloworld

2. java调用自定义native方法步骤

在java中使用native的步骤:
1.在java代码中声明native方法
2.执行javah来生成一个.h文件
3.写.cpp文件来实现native导出的方法,需要包含上面第二步产生的.h文件,同时也包含了jdk自带的jni.h
4.将第三步的.cpp文件通过gcc 编译成动态链接库文件
5.在java中使用的用System.loadLibrary()方法加载第四步产生的动态链接库文件,这个native()方法就可以在Java中被访问
一般情况下,我们jdk中声明的native方法,在编译的时候都会自动去加载动态链接库文件,而不需要我们自己去操作了。

3.使用native的缺点

使用native的缺点:可移植性差,把对底层的控制权交给其他语言,那么也会出现不稳定性,庆幸的是现在操作系统的底层实现基本不会改变。上面hsahcode()的计算真是通过内存所在的内存块来计算的,java是无法直接操作内存的。

【作者简介】
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使缓慢,驰而不息。这个世界希望一切都很快,更快,但是我希望自己能走好每一步,写好每一篇文章,期待和你们一起交流。

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

查看原文

赞 1 收藏 1 评论 0

秦怀杂货店 发布了文章 · 11月28日

serialVersionUID作用是什么以及如何生成的?

正常不设置serialVersionUID 的序列化和反序列化

先定义一个实体Student.class,需要实现Serializable接口,但是不需要实现get(),set()方法


import java.io.Serializable;
public class Student implements Serializable {
    private int age;
    private String name;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

测试类,思路是先把Student对象序列化到Student.txt文件,然后再讲Student.txt文件反序列化成对象,输出。

public class SerialTest {
    public static void main(String[] args) {
        serial();
        deserial();
    }
    // 序列化
    private static void serial(){
        Student student = new Student(9, "Mike");
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("Student.txt");
            ObjectOutputStream objectOutputStream= new ObjectOutputStream(fileOutputStream);
            objectOutputStream.writeObject(student);
            objectOutputStream.flush();
        } catch (Exception exception) {
            exception.printStackTrace();
        }
    }
    // 反序列化
    private static void deserial() {
        try {
            FileInputStream fis = new FileInputStream("Student.txt");
            ObjectInputStream ois = new ObjectInputStream(fis);
            Student student = (Student) ois.readObject();
            ois.close();
            System.out.println(student.toString());
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

输出结果,序列化文件我们可以看到Student.txt,反序列化出来,里面的字段都是不变的,说明反序列化成功了。

序列化之后,类文件增加了字段,反序列化会怎么样?

先说结果,会失败!!!

我们在Student.java中增加了一个属性score,重新生成了toString()方法。

package com.aphysia.normal;

import java.io.Serializable;

public class Student implements Serializable {
    private int age;
    private String name;
    private int score;
    public Student(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", name='" + name + '\'' +
                ", score=" + score +
                '}';
    }
}

然后重新调用deserial()方法,会报错:

java.io.InvalidClassException: com.aphysia.normal.Student; local class incompatible: stream classdesc serialVersionUID = 7488921480006384819, local class serialVersionUID = 6126416635811747983
    at java.io.ObjectStreamClass.initNonProxy(ObjectStreamClass.java:699)
    at java.io.ObjectInputStream.readNonProxyDesc(ObjectInputStream.java:1963)
    at java.io.ObjectInputStream.readClassDesc(ObjectInputStream.java:1829)
    at java.io.ObjectInputStream.readOrdinaryObject(ObjectInputStream.java:2120)
    at java.io.ObjectInputStream.readObject0(ObjectInputStream.java:1646)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:482)
    at java.io.ObjectInputStream.readObject(ObjectInputStream.java:440)
    at com.aphysia.normal.SerialTest.deserial(SerialTest.java:26)
    at com.aphysia.normal.SerialTest.main(SerialTest.java:7)

从上面的报错信息中,我们可以看到,类型不匹配,主要是因为serialVersionUID变化了!!!

🙋‍♂️🙋‍♂️ 提问环节:我都没有设置serialVersionUID,怎么变化的???小小的脑袋很多问号🤔🤔

正是因为没有设置,所以变化了,因为我们增加了一个字段score,如果我们不设置serialVersionUID,系统就会自动生成,自动生成有风险,就是我们的字段类型或者长度改变(新增或者删除的时候),自动生成的serialVersionUID会发生变化,那么以前序列化出来的对象,反序列化的时候就会失败。

实测:序列化完成之后,如果原类型字段减少,不指定serialVersionUID的情况下,也是会报不一致的错误。

《阿里巴巴 Java 开发手册》中规定,在兼容性升级中,在修改类的时候,不要修改serialVersionUID的原因。除非是完全不兼容的两个版本。所以,serialVersionUID其实是验证版本一致性的。

指定serialVersionUID,减少或者增加字段会发生什么?

我们生成一个serialVersionUID,方法:https://blog.csdn.net/Aphysia...

    private static final long serialVersionUID = 7488921480006384819L;

然后执行序列化,序列化出文件Student.txt后,增加一个字段score,执行反序列化。
是可以成功的!!!只是新增的字段是默认值0。

所以今后考虑到迭代的问题的时候,一般可能增加字段或者减少字段,都是需要考虑兼容问题的,所以最好是自己指定serialVersionUID,而不是由系统自动生成。自动生成的,由于类文件变化,它也会发生变化,就会出现不一致的问题,导致反序列化失败。

实测:如果我减少了字段,只要指定了serialVersionUID,也不会报错!!!

serialVersionUID生成以及作用?

serialVersionUID是为了兼容不同版本的,在JDK中,可以利用JDK的bin目录下的serialver.exe工具产生这个serialVersionUID,对于Student.class,执行命令:serialver Student

IDEA生成实际上也是调用这个命令,代码调用可以这样写:

ObjectStreamClass c = ObjectStreamClass.lookup(Student.class);
long serialID = c.getSerialVersionUID();
System.out.println(serialID);

如果不显示的指定,那么不同JVM之间的移植可能也会出错,因为不同的编译器,计算这个值的策略可能不同,计算类没有修改,也会出现不一致的问题。
getSerialVersionUID()源码如下:

    public long getSerialVersionUID() {
        // REMIND: synchronize instead of relying on volatile?
        if (suid == null) {
            suid = AccessController.doPrivileged(
                new PrivilegedAction<Long>() {
                    public Long run() {
                        return computeDefaultSUID(cl);
                    }
                }
            );
        }
        return suid.longValue();
    }

可以看到上面是使用了一个内部类的方式,使用特权计算computeDefaultSUID():

    private static long computeDefaultSUID(Class<?> cl) {
        // 代理
        if (!Serializable.class.isAssignableFrom(cl) || Proxy.isProxyClass(cl))
        {
            return 0L;
        }

        try {
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            DataOutputStream dout = new DataOutputStream(bout);
            // 类名
            dout.writeUTF(cl.getName());

            // 修饰符
            int classMods = cl.getModifiers() &
                (Modifier.PUBLIC | Modifier.FINAL |
                 Modifier.INTERFACE | Modifier.ABSTRACT);

            //  方法
            Method[] methods = cl.getDeclaredMethods();
            if ((classMods & Modifier.INTERFACE) != 0) {
                classMods = (methods.length > 0) ?
                    (classMods | Modifier.ABSTRACT) :
                    (classMods & ~Modifier.ABSTRACT);
            }
            dout.writeInt(classMods);

            if (!cl.isArray()) {
                // 继承的接口
                Class<?>[] interfaces = cl.getInterfaces();
                String[] ifaceNames = new String[interfaces.length];
                for (int i = 0; i < interfaces.length; i++) {
                    ifaceNames[i] = interfaces[i].getName();
                }
                // 接口名
                Arrays.sort(ifaceNames);
                for (int i = 0; i < ifaceNames.length; i++) {
                    dout.writeUTF(ifaceNames[i]);
                }
            }
            // 属性
            Field[] fields = cl.getDeclaredFields();
            MemberSignature[] fieldSigs = new MemberSignature[fields.length];
            for (int i = 0; i < fields.length; i++) {
                fieldSigs[i] = new MemberSignature(fields[i]);
            }
            Arrays.sort(fieldSigs, new Comparator<MemberSignature>() {
                public int compare(MemberSignature ms1, MemberSignature ms2) {
                    return ms1.name.compareTo(ms2.name);
                }
            });
            for (int i = 0; i < fieldSigs.length; i++) {
                // 成员签名
                MemberSignature sig = fieldSigs[i];
                int mods = sig.member.getModifiers() &
                    (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
                     Modifier.STATIC | Modifier.FINAL | Modifier.VOLATILE |
                     Modifier.TRANSIENT);
                if (((mods & Modifier.PRIVATE) == 0) ||
                    ((mods & (Modifier.STATIC | Modifier.TRANSIENT)) == 0))
                {
                    dout.writeUTF(sig.name);
                    dout.writeInt(mods);
                    dout.writeUTF(sig.signature);
                }
            }
            // 是否有静态初始化
            if (hasStaticInitializer(cl)) {
                dout.writeUTF("<clinit>");
                dout.writeInt(Modifier.STATIC);
                dout.writeUTF("()V");
            }
            // 构造器
            Constructor<?>[] cons = cl.getDeclaredConstructors();
            MemberSignature[] consSigs = new MemberSignature[cons.length];
            for (int i = 0; i < cons.length; i++) {
                consSigs[i] = new MemberSignature(cons[i]);
            }
            Arrays.sort(consSigs, new Comparator<MemberSignature>() {
                public int compare(MemberSignature ms1, MemberSignature ms2) {
                    return ms1.signature.compareTo(ms2.signature);
                }
            });
            for (int i = 0; i < consSigs.length; i++) {
                MemberSignature sig = consSigs[i];
                int mods = sig.member.getModifiers() &
                    (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
                     Modifier.STATIC | Modifier.FINAL |
                     Modifier.SYNCHRONIZED | Modifier.NATIVE |
                     Modifier.ABSTRACT | Modifier.STRICT);
                if ((mods & Modifier.PRIVATE) == 0) {
                    dout.writeUTF("<init>");
                    dout.writeInt(mods);
                    dout.writeUTF(sig.signature.replace('/', '.'));
                }
            }

            MemberSignature[] methSigs = new MemberSignature[methods.length];
            for (int i = 0; i < methods.length; i++) {
                methSigs[i] = new MemberSignature(methods[i]);
            }
            Arrays.sort(methSigs, new Comparator<MemberSignature>() {
                public int compare(MemberSignature ms1, MemberSignature ms2) {
                    int comp = ms1.name.compareTo(ms2.name);
                    if (comp == 0) {
                        comp = ms1.signature.compareTo(ms2.signature);
                    }
                    return comp;
                }
            });
            for (int i = 0; i < methSigs.length; i++) {
                MemberSignature sig = methSigs[i];
                int mods = sig.member.getModifiers() &
                    (Modifier.PUBLIC | Modifier.PRIVATE | Modifier.PROTECTED |
                     Modifier.STATIC | Modifier.FINAL |
                     Modifier.SYNCHRONIZED | Modifier.NATIVE |
                     Modifier.ABSTRACT | Modifier.STRICT);
                if ((mods & Modifier.PRIVATE) == 0) {
                    dout.writeUTF(sig.name);
                    dout.writeInt(mods);
                    dout.writeUTF(sig.signature.replace('/', '.'));
                }
            }

            dout.flush();

            MessageDigest md = MessageDigest.getInstance("SHA");
            byte[] hashBytes = md.digest(bout.toByteArray());
            long hash = 0;
            for (int i = Math.min(hashBytes.length, 8) - 1; i >= 0; i--) {
                hash = (hash << 8) | (hashBytes[i] & 0xFF);
            }
            return hash;
        } catch (IOException ex) {
            throw new InternalError(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new SecurityException(ex.getMessage());
        }
    }

从上面这段源码大致来看,其实这个计算`serialVersionUID,基本是将类名,属性名,属性修饰符,继承的接口,属性类型,名称,方法,静态代码块等等...这些都考虑进去了,都写到一个DataOutputStream中,然后再做hash运算,所以说,这个东西得指定啊,不指定的话,稍微一改类的东西,就变了...

而且这个东西指定了,没啥事,不要改!!!除非你确定两个版本就不兼容!!!
没事...
没事..
没事.
没事

此文章仅代表自己(本菜鸟)学习积累记录,或者学习笔记,如有侵权,请联系作者删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有错误之处,还望指出,感激不尽~

技术之路不在一时,山高水长,纵使缓慢,驰而不息。

公众号:秦怀杂货店

查看原文

赞 0 收藏 0 评论 0

认证与成就

  • 获得 2 次点赞
  • 获得 1 枚徽章 获得 0 枚金徽章, 获得 0 枚银徽章, 获得 1 枚铜徽章

擅长技能
编辑

开源项目 & 著作
编辑

(゚∀゚ )
暂时没有

注册于 8月14日
个人主页被 451 人浏览