搜索词>>伪静态 耗时0.0020
  • typecho 301伪静态配置

    typecho 301伪静态配置typecho 301伪静态配置,步骤一:apache启用加载htaccess文件
  • Linux系统修改静态IP

    Linux系统修改静态IPLinux系统修改静态IP<br />   <pre> <code>#vi /etc/sysconfig/network-script/ifcfg-eth0</code></pre> <img alt="1" class="img-thumbnail" src="/assist/images/blog/a64b06b1-4098-4da6-8f5e-1ebfe662d755.png" style="height:152px; width:376px" /><br /> 修改为: <pre> <code>DEVICE="eth0" BOOTPROTO="static" HWADDR="00:0C:29:91:39:87" ONBOOT="yes" IPADDR=172.16.0.227 NETMASK=255.255.255.0 GATEWAY=172.16.0.1</code></pre>   <pre> <code>#/etc/init.d/network restart #ifconfig</code></pre> 以下为CentOS7修改示例:<br /> 修改前配置:<br /> <img alt="0" class="img-thumbnail" src="/assist/images/blog/05994a01-3259-435c-8137-f419ab85f1c4.png" style="height:337px; width:459px" /><br /> 修改后配置:[红色标记为修改操作]<br /> <img alt="11" class="img-thumbnail" src="/assist/images/blog/1159c282-3bcc-414a-9ba1-8ba159780eb8.png" style="height:498px; width:729px" /><br /> <span style="color:#cc0000"><strong>注意图片中是GATEWAY</strong></span><br /> <br /> <img alt="123" class="img-thumbnail" src="/assist/images/blog/222d7ab7-a643-42c4-82a8-562b51556f79.png" style="height:422px; width:717px" /><br /> [注意:由于测试机的centos7系统网卡名称为eno16777736,所以编辑的配置文件为:] <pre> <code>[root@localhost ~]# vi /etc/sysconfig/network-scripts/ifcfg-eno16777736</code></pre>
  • linux 配置静态ip地址

    linux 配置静态ip地址,Centos6.5配置静态IP地址,Linux系统配置静态IP地址<h2><span style="font-family:宋体">一、切换用户</span></h2> <p><span style="font-family:宋体">切换用户为</span>root<span style="font-family:宋体">用户</span>,<span style="font-family:宋体">如果已经是</span>root<span style="font-family:宋体">用户则忽略该步骤</span></p> <p><span style="font-family:宋体">执行命令</span>:</p> <p><strong><em>su –</em></strong></p> <p><span style="font-family:宋体">回车</span></p> <p><span style="font-family:宋体">输入</span>root<span style="font-family:宋体">用户密码</span></p> <p> </p> <p><span style="font-family:宋体">切换为</span>root<span style="font-family:宋体">用户后</span>,<span style="font-family:宋体">可以看到是以</span>#<span style="font-family:宋体">开头</span></p> <p><img alt="切换用户" class="img-thumbnail" src="/assist/images/blog/931479862dc1404b82eef2d5ff69b39e.png" /></p> <h2><span style="font-family:宋体">二、查看当前网卡信息</span></h2> <p><span style="font-family:宋体">查看当前的网卡信息可以通过命令</span>ifconfig<span style="font-family:宋体">来查看</span></p> <p><span style="font-family:宋体">命令</span>:</p> <p>#ifconfig</p> <p><img alt="查看网卡信息" class="img-thumbnail" src="/assist/images/blog/897f349dc00e43968060ace0291b862d.png" /></p> <p><span style="font-family:宋体">从上面可以看到</span>IP<span style="font-family:宋体">地址现在是</span>192.168.8.113</p> <h2><span style="font-family:宋体">二、修改网卡配置</span></h2> <p><span style="font-family:宋体">修改网卡</span>eth0<span style="font-family:宋体">的配置文件</span>,<span style="font-family:宋体">默认情况</span>eth0<span style="font-family:宋体">的配置如下</span>:</p> <p><span style="font-family:宋体">命令</span>:</p> <p>[root@bogon ~]# cat  /etc/sysconfig/network-scripts/ifcfg-eth0</p> <p>DEVICE="eth0"</p> <p>BOOTPROTO="dhcp"</p> <p>HWADDR="00:0C:29:3C:EF:C2"</p> <p>IPV6INIT="yes"</p> <p>NM_CONTROLLED="yes"</p> <p>ONBOOT="yes"</p> <p>TYPE="Ethernet"</p> <p>UUID="4375e220-3ef8-4e8c-9de4-9e2ee9007c88"</p> <p> </p> <p><span style="font-family:宋体">默认情况是通过</span>dhcp<span style="font-family:宋体">动态获取</span>ip<span style="font-family:宋体">地址</span>,<span style="font-family:宋体">现在我们需要修改该配置文件</span>,<span style="font-family:宋体">让其使用静态</span>IP<span style="font-family:宋体">地址</span></p> <p><span style="font-family:宋体">通过</span>vi<span style="font-family:宋体">命令编辑网卡配置文件</span>/etc/sysconfig/network-scripts/ifcfg-eth0,<span style="font-family:宋体">将上面的内容修改为</span>:</p> <p>[root@bogon ~]# vi   /etc/sysconfig/network-scripts/ifcfg-eth0<span style="font-family:宋体">(<em>打开文件后按键盘的小写</em></span><em>i</em><em><span style="font-family:宋体">进行编辑</span></em><span style="font-family:宋体">)</span></p> <p>DEVICE="eth0"</p> <p>BOOTPROTO="<span style="color:red">static</span>"</p> <p>HWADDR="00:0C:29:3C:EF:C2"</p> <p>IPV6INIT="yes"</p> <p>NM_CONTROLLED="yes"</p> <p>ONBOOT="yes"</p> <p>TYPE="Ethernet"</p> <p>UUID="4375e220-3ef8-4e8c-9de4-9e2ee9007c88"</p> <p><span style="color:red">IPADDR=192.168.8.202</span></p> <p><span style="color:red">GATEWAY=192.168.8.1</span></p> <p><span style="color:red">NETMASK=255.255.255.0</span></p> <p><span style="color:red">DNS1=8.8.8.8</span></p> <p><span style="font-family:宋体">上面标记为红色为修改或添加部分</span>,<span style="font-family:宋体">简单说明</span>:</p> <p>BOOTPROTO="<span style="color:red">static</span>"            <span style="font-family:Wingdings">à</span><span style="font-family:宋体">修改网卡获取</span>IP<span style="font-family:宋体">地址的方式为静态</span></p> <p><span style="color:red">IPADDR=192.168.8.202                    </span>–><span style="font-family:宋体">静态</span>IP<span style="font-family:宋体">地址</span></p> <p><span style="color:red">GATEWAY=192.168.8.1</span>          -><span style="font-family:宋体">网关地址</span></p> <p><span style="color:red">NETMASK=255.255.255.0      </span>-><span style="font-family:宋体">掩码地址</span></p> <p><span style="color:red">DNS1=8.8.8.8                              </span>->NDS<span style="font-family:宋体">地址</span></p> <p><span style="font-family:宋体">修改完成后保存配置文件(</span>vi<span style="font-family:宋体">命令</span>:<em><span style="font-family:宋体">按</span>esc</em><em><span style="font-family:宋体">键</span>,</em><em><span style="font-family:宋体">输入</span>:wq!</em><em><span style="font-family:宋体">回车)</span></em></p> <p><strong><em><span style="font-family:宋体">注意配置文件中</span> HWADDR</em></strong><strong><em><span style="font-family:宋体">和</span>DEVICE</em></strong><strong><em><span style="font-family:宋体">值必须与</span>ifconfig</em></strong><strong><em><span style="font-family:宋体">中显示的一直</span>,</em></strong><strong><em><span style="font-family:宋体">以</span>ifconfig</em></strong><strong><em><span style="font-family:宋体">命令显示的信息为准。</span></em></strong></p> <p> </p> <p><img alt="修改静态iP" class="img-thumbnail" src="/assist/images/blog/beb5829a02f4421fae2c3684012660e3.png" /></p> <h2><span style="font-family:宋体">三、重启网卡服务</span></h2> <p><span style="font-family:宋体">重启系统的网卡服务,让刚才的配置生效</span></p> <p><span style="font-family:宋体">重启网卡服务命令</span>:</p> <p>[root@localhost ~]# service network restart</p> <p>Shutting down interface eth0:  Device state: 3 (disconnected)</p> <p>                                                           [  OK  ]</p> <p>Shutting down loopback interface:                          [  OK  ]</p> <p>Bringing up loopback interface:                            [  OK  ]</p> <p>Bringing up interface eth0:  Active connection state: activating</p> <p>Active connection path: /org/freedesktop/NetworkManager/ActiveConnection/4</p> <p>state: activated</p> <p>Connection activated</p> <p>                                                           [  OK  ]</p> <p><img alt="重启网卡服务" class="img-thumbnail" src="/assist/images/blog/813801b618794496bc4532ac2e0f8825.png" /></p> <p> </p> <p><span style="font-family:宋体">重启成功后再次查看本机的</span>ip<span style="font-family:宋体">信息</span></p> <p>[root@localhost ~]# ifconfig</p> <p>eth0      Link encap:Ethernet  HWaddr 00:0C:29:3C:EF:C2 </p> <p>          inet addr:192.168.8.202  Bcast:192.168.8.255  Mask:255.255.255.0</p> <p>          inet6 addr: fe80::20c:29ff:fe3c:efc2/64 Scope:Link</p> <p>          UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1</p> <p>          RX packets:28655 errors:0 dropped:0 overruns:0 frame:0</p> <p>          TX packets:908 errors:0 dropped:0 overruns:0 carrier:0</p> <p>          collisions:0 txqueuelen:1000</p> <p>          RX bytes:2308026 (2.2 MiB)  TX bytes:133068 (129.9 KiB)</p> <p> </p> <p>lo        Link encap:Local Loopback </p> <p>          inet addr:127.0.0.1  Mask:255.0.0.0</p> <p>          inet6 addr: ::1/128 Scope:Host</p> <p>          UP LOOPBACK RUNNING  MTU:16436  Metric:1</p> <p>          RX packets:104 errors:0 dropped:0 overruns:0 frame:0</p> <p>          TX packets:104 errors:0 dropped:0 overruns:0 carrier:0</p> <p>          collisions:0 txqueuelen:0</p> <p>          RX bytes:8276 (8.0 KiB)  TX bytes:8276 (8.0 KiB)</p> <p> </p> <p>[root@localhost ~]#</p>
  • spring boot 2.x设置静态资源缓存时间

    spring boot 2.x设置静态资源缓存时间找到项目配置文件application.properties添加内容:spring.resources.cache-period=2d解释:2d--->>2天2s---->>2秒2m--->>2分钟2h---->>2小时注意:spring boot 2.0 必须配置单位
  • Java编程之java static关键字

    Java编程之java static关键字,Java编程,static关键字<h2>一、java中static关键字</h2> java中的static关键字可以应用于变量、方法、块、导入和内部类。在本教程中,我们将了解在这些地方使用static关键字的效果。<br /> <br /> 本文将要讲解的内容目录: <ul> <li>Static 变量的使用讲解</li> <li>Static 方法的使用讲解</li> <li>Static 导入声明使用讲解</li> <li>Static 块的使用讲解</li> <li>Static 类的使用讲解</li> <li>static关键字使用总结</li> </ul> <h2>二、static变量</h2> 要声明一个static变量,请在变量声明中使用static关键字。static变量的语法是: <pre> <code>ACCESS_MODIFER static DATA_TYPE VARNAME;</code></pre> 例如,用这种方式声明整数类型的公共静态变量。 <pre> <code class="language-java">public static Integer staticVar;</code></pre> 静态变量最重要的一点是它们属于类级别。这意味着在运行时只能有一个变量的副本。当在类定义中定义静态变量时,类的每个实例都可以访问该单一副本。单独的类实例不会有它们自己的本地副本,就像它们对非静态变量一样。<br /> <br /> 让我们来了解一个例子: <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { DataObject objOne = new DataObject(); objOne.staticVar = 10; objOne.nonStaticVar = 20; DataObject objTwo = new DataObject(); System.out.println(objTwo.staticVar); //10 System.out.println(objTwo.nonStaticVar); //null DataObject.staticVar = 30; //Direct Access System.out.println(objOne.staticVar); //30 System.out.println(objTwo.staticVar); //30 } } class DataObject { public static Integer staticVar; public Integer nonStaticVar; }</code></pre> <br /> 输出内容: <pre> <code>10 null 30 30</code></pre> 注意我们如何将值更改为30,并且这两个对象现在看到的更新值为30。<br /> <br /> 另一件您应该注意到的是,我们如何能够使用它的类名来访问静态变量,即dataobject . staticvar。我们不需要创建任何实例来访问静态变量。它清楚地表明静态变量属于类范围。 <h2>三、static方法</h2> 要声明静态方法,请在方法声明中使用静态关键字。静态方法的语法是: <pre> <code>ACCESS_MODIFER static RETURN_TYPE METHOD_NAME;</code></pre> <br /> 例如,用这种方式声明整数类型的公共静态变量。 <pre> <code class="language-java">public static Integer getStaticVar(){ return staticVar; }</code></pre> <p>要记住的一些事项。</p> <ol> <li>您只能在静态方法中访问静态变量。如果您尝试访问任何非静态变量,将生成的编译器错误信息“无法对非静态字段非静态变量进行静态引用”。</li> <li>静态方法可以通过它的类引用来访问,并且不需要创建类的实例。虽然您也可以使用实例引用,但是与通过类引用的访问相比,它不会有任何不同。</li> <li>静态方法也属于类级范围。</li> </ol>   <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { DataObject.staticVar = 30; //Direct Access Integer value1 = DataObject.getStaticVar(); //access with class reference DataObject objOne = new DataObject(); Integer value2 = objOne.getStaticVar(); //access with instance reference System.out.println(value1); System.out.println(value2); } } class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable public static Integer getStaticVar(){ return staticVar; } }</code></pre> 输出内容: <pre> <code>30 30</code></pre> <h2>四、static Import 声明</h2> <p>    正常的导入声明从包中导入类,因此它们可以在没有包引用的情况下使用。类似地,静态导入声明从类中导入静态成员,并允许它们在没有类引用的情况下使用。</p> <p>    静态导入声明也有两种类型:单静态导入和静态导入。单静态导入声明从类型中导入一个静态成员。静态输入-点播声明导入了类型的所有静态成员。<br />  </p> <pre> <code class="language-java">//Single-static-import declaration: import static <<package name>>.<<type name>>.<<static member name>>; //Static-import-on-demand declaration: import static <<package name>>.<<type name>>.*;</code></pre> 例如, <code>System.out</code> is <pre> <code class="language-java">//Static import statement import static java.lang.System.out; public class JavaStaticExample { public static void main(String[] args) { DataObject.staticVar = 30; out.println(DataObject.staticVar); //Static import statement example } } class DataObject { public static Integer staticVar; //static variable }</code></pre> 输出: <pre> <code>30</code></pre> <h2>五、Static 块</h2> 静态块是类初始化代码的一部分,它用静态关键字包装。一般的语法是: <pre> <code class="language-java">static { //initialize static members of class }</code></pre> 当类装入内存时,将执行静态块。一个类可以有多个静态块,并且它们将以相同的顺序执行,它们在类定义中出现。 <pre> <code class="language-java">import static java.lang.System.out; class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable //It will be executed first static { staticVar = 40; //nonStaticVar = 20; //Not possible to access non-static members } //It will be executed second static { out.println(staticVar); } }</code></pre> 输出: <pre> <code>40</code></pre> <h2>六、static 类</h2> 在java中,可以将静态类作为内部类。与其他静态成员一样,嵌套的类属于类范围,所以可以访问内部的静态类,而不具有外部类的对象。 <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { //Static inner class example System.out.println( DataObject.StaticInnerClas.innerStaticVar ); } } class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable static class StaticInnerClas { Integer innerNonStaticVar = 60; static Integer innerStaticVar = 70; //static variable inside inner class } }</code></pre> 请注意,静态内部类无法访问外部类的非静态成员。它只能访问来自外部类的静态成员。 <pre> <code class="language-java">public class JavaStaticExample { public static void main(String[] args) { //Static inner class example DataObject.StaticInnerClas.accessOuterClass(); } } class DataObject { public Integer nonStaticVar; public static Integer staticVar; //static variable static { staticVar = 40; //nonStaticVar = 20; //Not possible to access non-static members } public static Integer getStaticVar(){ return staticVar; } static class StaticInnerClas { public static void accessOuterClass() { System.out.println(DataObject.staticVar); //static variable of outer class System.out.println(DataObject.getStaticVar()); //static method of outer class } } }</code></pre> 输出: <pre> <code>40</code></pre> <h2>七、总结</h2> 让我们总结一下java中静态使用的所有内容。 <ol> <li>静态成员属于类。不需要创建类实例来访问静态成员。</li> <li>静态成员(变量和方法)只能在静态方法和静态块中访问。</li> <li>不能在静态方法、块和内部类中访问非静态成员。</li> <li>一个类可以有多个静态块,它们将按照类定义的顺序执行。</li> <li>只有当类声明为内部类内部类时,类才能是静态的。</li> <li>静态导入可用于从类导入所有的静态成员。这些成员可以被引用,没有任何类引用。</li> </ol>
  • Java 类加载机制

    Java 类加载机制<h2>1.Java类加载流程图</h2> <img alt="类加载流程图" class="img-thumbnail" src="/assist/images/blog/a5fad6dfbb004e239876373a08e30a0c.gif" /> <h2>2.类的初始化</h2> 类什么时候才被初始化: <p><span style="color:#16a085">1)创建类的实例,也就是new一个对象<br /> 2)访问某个类或接口的静态变量,或者对该静态变量赋值<br /> 3)调用类的静态方法<br /> 4)反射(Class.forName("com.lyj.load"))<br /> 5)初始化一个类的子类(会首先初始化子类的父类)<br /> 6)JVM启动时标明的启动类,即文件名和类名相同的那个类</span></p> 只有这6中情况才会导致类的类的初始化。 <p>假如这个类存在直接父类,并且这个类还没有被初始化(注意:在一个类加载器中,类只能初始化一次),那就初始化直接的父类(不适用于接口)<br /> 加入类中存在初始化语句(如static变量和static块),那就依次执行这些初始化语句。</p> <h2>3.类的加载</h2>   类的加载指的是将类的.class文件中的二进制数据读入到内存中,将其放在运行时数据区的方法区内,然后在堆区创建一个这个类的Java.lang.Class对象,用来封装类在方法区类的对象。<br /> <img alt="" class="img-thumbnail" src="/assist/images/blog/77a455e73f0548808e25afb18c0d3828.gif" /><br /> 类加载器:<br /> <img alt="类加载器:" class="img-thumbnail" src="/assist/images/blog/35a17133b1c743dd80041c967d51a7ad.gif" /><br />   <pre> <code class="language-java">import java.net.URL; public class Main { public static void main(String[] args) { URL[] urls=sun.misc.Launcher.getBootstrapClassPath().getURLs(); for (int i = 0; i < urls.length; i++) { System.out.println(urls[i].toExternalForm()); } } }</code></pre> <pre> <code>file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/resources.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/rt.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/sunrsasign.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/jsse.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/jce.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/charsets.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/lib/jfr.jar file:/D:/Program%20Files/Java/jdk1.8.0_102/jre/classes</code></pre> <h2>4.Java类加载机制</h2> <p>类装载器就是寻找类的字节码文件,并构造出类在JVM内部表示的对象组件。在Java中,类装载器把一个类装入JVM中,要经过以下步骤:<br /> (1) 装载:查找和导入Class文件;<br /> (2) 链接:把类的二进制数据合并到JRE中;<br />     (a)校验:检查载入Class文件数据的正确性;<br />     (b)准备:给类的静态变量分配存储空间;<br />     (c)解析:将符号引用转成直接引用;<br /> (3) 初始化:对类的静态变量,静态代码块执行初始化操作</p> <p>类加载器和双亲委派模型</p> <p>(1) Bootstrap ClassLoader : 将存放于<JAVA_HOME>\lib目录中的,或者被-Xbootclasspath参数所指定的路径中的,并且是虚拟机识别的(仅按照文件名识别,如 rt.jar 名字不符合的类库即使放在lib目录中也不会被加载)类库加载到虚拟机内存中。启动类加载器无法被Java程序直接引用<br /> (2) Extension ClassLoader : 将<JAVA_HOME>\lib\ext目录下的,或者被java.ext.dirs系统变量所指定的路径中的所有类库加载。开发者可以直接使用扩展类加载器。<br /> (3) Application ClassLoader : 负责加载用户类路径(ClassPath)上所指定的类库,开发者可直接使用。</p> <p>双亲委派模型的工作过程:如果一个类加载器收到了类加载的请求,它首先不会自己去尝试加载这个类,而是把这个请求委派给父类加载器去完成,每个层次的类加载器都是如此。因此所有的加载请求最终都应该传达到顶层的启动类加载器中,只有当父加载器反馈无法完成这个加载请求(它的搜索范围中没有找到所需的类)时,子加载器才会尝试自己去加载。</p> <p>双亲委派模型要求除了顶层的启动类加载器外,其余的类加载器都应有自己的父类加载器。这些类加载器的父子关系不是以继承的关系实现,而都是使用组合关系来复用父加载器的代码。<br />  </p> <pre> <code class="language-java">public class ClassLoaderTest { public static void main(String[] args) { //输出ClassLoaderText的类加载器名称 System.out.println("ClassLoaderText类的加载器的名称:" + ClassLoaderTest.class.getClassLoader().getClass().getName()); System.out.println("System类的加载器的名称:" + System.class.getClassLoader()); System.out.println("ArrayList类的加载器的名称:" + ArrayList.class.getClassLoader()); ClassLoader cl = ClassLoaderTest.class.getClassLoader(); while (cl != null) { System.out.print(cl.getClass().getName() + "->"); cl = cl.getParent(); } System.out.println(cl); } }</code></pre> <pre> <code class="language-html">ClassLoaderText类的加载器的名称:sun.misc.Launcher$AppClassLoader System类的加载器的名称:null ArrayList类的加载器的名称:null sun.misc.Launcher$AppClassLoader->sun.misc.Launcher$ExtClassLoader->null</code></pre> 好处:java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如类java.lang.Object,它存放在rt.jar中,无论哪个类加载器要加载这个类,最终都会委派给启动类加载器进行加载,因此Object类在程序的各种类加载器环境中都是同一个类。相反,如果用户自己写了一个名为java.lang.Object的类,并放在程序的Classpath中,那系统中将会出现多个不同的Object类,java类型体系中最基础的行为也无法保证,应用程序也会变得一片混乱。
  • Java中的五种单例模式

    Java中的五种单例模式解法一:只适合单线程环境(不建议) <pre> <code class="language-java">public class Singleton { private static Singleton instance=null; private Singleton(){ } public static Singleton getInstance(){ if(instance==null){ instance=new Singleton(); } return instance; } }</code></pre> <p>注解:Singleton的静态属性instance中,只有instance为null的时候才创建一个实例,构造函数私有,确保每次都只创建一个,避免重复创建。<br /> 缺点:只在单线程的情况下正常运行,在多线程的情况下,就会出问题。例如:当两个线程同时运行到判断instance是否为空的if语句,并且instance确实没有创建好时,那么两个线程都会创建一个实例。</p> <p>解法二:多线程的情况可以用。(懒汉式,不建议)<br />  </p> <pre> <code class="language-java">public class Singleton { private static Singleton instance=null; private Singleton(){ } public static synchronized Singleton getInstance(){ if(instance==null){ instance=new Singleton(); } return instance; } }</code></pre> 注解:在解法一的基础上加上了同步锁,使得在多线程的情况下可以用。例如:当两个线程同时想创建实例,由于在一个时刻只有一个线程能得到同步锁,当第一个线程加上锁以后,第二个线程只能等待。第一个线程发现实例没有创建,创建之。第一个线程释放同步锁,第二个线程才可以加上同步锁,执行下面的代码。由于第一个线程已经创建了实例,所以第二个线程不需要创建实例。保证在多线程的环境下也只有一个实例。<br /> 缺点:每次通过getInstance方法得到singleton实例的时候都有一个试图去获取同步锁的过程。而众所周知,加锁是很耗时的。能避免则避免。<br /> <br /> 解法三:加同步锁时,前后两次判断实例是否存在(可行) <pre> <code class="language-java">public class Singleton { private static Singleton instance=null; private Singleton(){ } public static Singleton getInstance(){ if(instance==null){ synchronized(Singleton.class){ if(instance==null){ instance=new Singleton(); } } } return instance; } }</code></pre> <p>注解:只有当instance为null时,需要获取同步锁,创建一次实例。当实例被创建,则无需试图加锁。<br /> 缺点:用双重if判断,复杂,容易出错。</p> <p>解法四:饿汉式(建议使用)<br />  </p> <pre> <code class="language-java">public class Singleton { private static Singleton instance=new Singleton(); private Singleton(){ } public static Singleton getInstance(){ return instance; } }</code></pre>   <p>注解:初试化静态的instance创建一次。如果我们在Singleton类里面写一个静态的方法不需要创建实例,它仍然会早早的创建一次实例。而降低内存的使用率。</p> <p>缺点:没有lazy loading的效果,从而降低内存的使用率。</p> <p>解法五:静态内部内。(建议使用)<br />  </p> <pre> <code class="language-java">public class Singleton { private Singleton(){ } private static class SingletonHolder{ private final static Singleton instance=new Singleton(); } public static Singleton getInstance(){ return SingletonHolder.instance; } }</code></pre> 注解:定义一个私有的内部类,在第一次用这个嵌套类时,会创建一个实例。而类型为SingletonHolder的类,只有在Singleton.getInstance()中调用,由于私有的属性,他人无法使用SingleHolder,不调用Singleton.getInstance()就不会创建实例。<br /> 优点:达到了lazy loading的效果,即按需创建实例。
  • Spring Boot 配置映射本地资源访问

    Spring Boot 配置映射本地资源访问注意配置为两个spring.mvc.static-path-pattern= spring.resources.static-locations=这两个配置的默认值是:spring.mvc.staSpring Boot 配置映射本地资源访问注意配置为两个spring.mvc.static-path-pattern= spring.resources.static-locations=这两个配置的默认值是:spring.mvc.static-path-pattern=/** spring.resources.static-locations=classpath:/META-INF/resources/,classpath:/resources/,classpath:/static/,classpath:/public/ 解释一下:这两个的默认配置意思是请求来了 /路径下的,先去找spring.resources.static-locations配置的几个目录下有没用静态的资源文件。访问各个目录的优先级为从左到右由高到低。问题来了,我们如果想添加一个本地的绝对路径映射该怎么配置呢?spring.resources.static-locations=classpath:/static,D:/sharew我最初以为这样就可以了,然而后面的配置并没有生效。。。。。注意!注意!注意!要像下面这样配置才能生效。spring.resources.static-locations=classpath:/static,file:D:/share
  • Java序列化和反序列化

    ​Java序列化的作用Java序列化允许将Java对象写入文件系统以进行永久存储,也可以将其写入网络以传输到其他应用程序​Java序列化的作用Java序列化允许将Java对象写入文件系统以进行永久存储,也可以将其写入网络以传输到其他应用程序。JAVA实现序列化Java中的序列化是通过Serializable接口实现的。 Java Serializable接口保证了序列化对象的能力。 此接口也建议我们使用serialVersioUID。Java序列化中的疑惑现在,即使您在应用程序类中同时使用了序列化和反序列化,您是否知道也有可能已经破坏您的设计呢? 下面让我们确定类中将来的更改,这些更改将是兼容的更改,而其他更改将证明是不兼容的更改。Java序列化不兼容的更改对类的不兼容更改是指不能保持互操作性的那些更改。 下面给出了在演化类时可能发生的不兼容更改(考虑默认的序列化或反序列化):删除字段--->如果在类中删除了某个字段,则写入的流将不包含其值。 当较早的类读取流时,该字段的值将设置为默认值,因为流中没有可用的值。 但是,此默认值可能会不利地损害早期版本兼容性的能力。将类上移或下移---->这是不允许的,因为流中的数据以错误的顺序显示。将非静态字段更改为静态或将非持久化态字段更改为持久化态--->当依赖默认序列化时,此更改等效于从类中删除字段。 该版本的类不会将该数据写入流,因此该类的早期版本将无法读取该数据。 与删除字段时一样,早期版本的字段将被初始化为默认值,这可能导致类以意外方式失败。更改原始字段的声明类型--->每个版本的类都使用其声明类型写入数据。 尝试读取该字段的早期版本的类将失败,因为流中的数据类型与该字段的类型不匹配。更改writeObject或readObject方法,使其不再写入或读取默认字段数据,或者对其进行更改,以使其尝试写入或读取默认字段数据,而先前版本则不这样做。 默认字段数据必须一致地出现在流中或不出现在流中。将类从“可序列化”更改为“可外部化”,反之亦然,这是不兼容的更改,因为流将包含与可用类的实现不兼容的数据。将类从非枚举类型更改为枚举类型,反之亦然,因为流将包含与可用类的实现不兼容的数据。删除Serializable或Externalizable是一项不兼容的更改,因为在编写时它将不再提供该类的旧版本所需的字段。如果该行为会产生与该类的任何旧版本不兼容的对象,则将writeReplace或readResolve方法添加到类是不兼容的。Java序列化兼容更改添加字段–当要重构的类的字段在流中不存在时,该对象中的该字段将被初始化为其类型的默认值。 如果需要特定于类的初始化,则该类可以提供一个readObject方法,该方法可以将字段初始化为非默认值。添加类–流将包含流中每个对象的类型层次结构。 将流中的此层次结构与当前类进行比较可以检测到其他类。 由于流中没有用于初始化对象的信息,因此该类的字段将被初始化为默认值。删除类–将流中的类层次结构与当前类的层次结构进行比较可以检测到某个类已被删除。 在这种情况下,从该流中读取与该类相对应的字段和对象。 原始字段将被丢弃,但是会创建由删除的类引用的对象,因为它们可能稍后在流中被引用。 当流被垃圾回收或重置时,它们将被垃圾回收添加writeObject / readObject方法–如果读取流的版本具有这些方法,则通常希望readObject读取默认序列化写入流中的所需数据。 在读取任何可选数据之前,应先调用defaultReadObject。 通常,writeObject方法将调用defaultWriteObject写入所需的数据,然后再写入可选数据。删除writeObject / readObject方法–如果读取流的类没有这些方法,则默认情况下将序列化读取所需的数据,并将丢弃可选数据。添加java.io.Serializable –这等效于添加类型。 该类的流中将没有任何值,因此其字段将被初始化为默认值。 对子类化不可序列化类的支持要求该类的超级类型具有no-arg构造函数,并且该类本身将被初始化为默认值。 如果no-arg构造函数不可用,则抛出InvalidClassException。更改对字段的访问权限–访问修饰符public,package,protected和private对序列化为字段分配值的能力没有影响。将字段从静态更改为非静态或将瞬态更改为非瞬态–当依靠默认序列化来计算可序列化字段时,此更改等效于将字段添加到类中。 新字段将被写入流,但是较早的类将忽略该值,因为序列化不会将值分配给静态或瞬态字段。Java序列化中的serialVersionUIDserialVersionUID是Serializable类的通用版本标识符。 反序列化使用此数字来确保已加载的类与序列化的对象完全对应。 如果找不到匹配项,则抛出InvalidClassException。始终将其包含为字段,例如:“ private static final long serialVersionUID = 7526472295622776147L; ”,即使在课程的第一个版本中也要包含此字段,以提醒其重要性。除非您有意对类进行更改以使其与旧的序列化对象不兼容,否则请勿在以后的版本中更改此字段的值。 如果需要,请遵循上述给定的准则。readObject和writeObject方法介绍反序列化必须视为任何构造函数:在反序列化结束时验证对象状态-这意味着readObject几乎应始终在Serializable类中实现,以便执行此验证。如果构造函数为可变对象字段制作防御性副本,则必须为readObject。一些序列化最佳实践使用javadoc的@serial标记表示可序列化字段。.ser扩展名通常用于表示序列化对象的文件。没有静态或瞬态字段接受默认序列化。除非必要,否则可扩展类不应是可序列化的。内部类很少(如果有的话)实现Serializable。容器类通常应遵循Hashtable的样式,该样式通过存储键和值来实现Serializable,而不是大型哈希表数据结构。遵循序列化最佳做法的演示package staticTest; import java.io.Serializable; import java.text.StringCharacterIterator; import java.util.*; import java.io.*; public final class UserDetails implements Serializable { /** * 此构造函数需要所有字段 * * @param aFirstName * contains only letters, spaces, and apostrophes. * @param aLastName * contains only letters, spaces, and apostrophes. * @param aAccountNumber * is non-negative. * @param aDateOpened * has a non-negative number of milliseconds. */ public UserDetails(String aFirstName, String aLastName, int aAccountNumber, Date aDateOpened) { super(); setFirstName(aFirstName); setLastName(aLastName); setAccountNumber(aAccountNumber); setDateOpened(aDateOpened); // there is no need here to call verifyUserDetails. } // 默认构造函数 public UserDetails() { this("FirstName", "LastName", 0, new Date(System.currentTimeMillis())); } public final String getFirstName() { return fFirstName; } public final String getLastName() { return fLastName; } public final int getAccountNumber() { return fAccountNumber; } /** * 返回该字段的防御性副本,因此没有人可以更改此字段。 * */ public final Date getDateOpened() { return new Date(fDateOpened.getTime()); } /** * Names must contain only letters, spaces, and apostrophes. Validate before * setting field to new value. * * @throws IllegalArgumentException * if the new value is not acceptable. */ public final void setFirstName(String aNewFirstName) { verifyNameProperty(aNewFirstName); fFirstName = aNewFirstName; } /** * Names must contain only letters, spaces, and apostrophes. Validate before * setting field to new value. * * @throws IllegalArgumentException * if the new value is not acceptable. */ public final void setLastName(String aNewLastName) { verifyNameProperty(aNewLastName); fLastName = aNewLastName; } /** * Validate before setting field to new value. * * @throws IllegalArgumentException * if the new value is not acceptable. */ public final void setAccountNumber(int aNewAccountNumber) { validateAccountNumber(aNewAccountNumber); fAccountNumber = aNewAccountNumber; } public final void setDateOpened(Date aNewDate) { // make a defensive copy of the mutable date object Date newDate = new Date(aNewDate.getTime()); validateAccountOpenDate(newDate); fDateOpened = newDate; } /** * The client's first name. * * @serial */ private String fFirstName; /** * The client's last name. * * @serial */ private String fLastName; /** * The client's account number. * * @serial */ private int fAccountNumber; /** * The date the account was opened. * * @serial */ private Date fDateOpened; /** * Determines if a de-serialized file is compatible with this class. * Included here as a reminder of its importance. */ private static final long serialVersionUID = 7526471155622776147L; /** * Verify that all fields of this object take permissible values * * @throws IllegalArgumentException * if any field takes an unpermitted value. */ private void verifyUserDetails() { validateAccountNumber(fAccountNumber); verifyNameProperty(fFirstName); verifyNameProperty(fLastName); validateAccountOpenDate(fDateOpened); } /** * Ensure names contain only letters, spaces, and apostrophes. * * @throws IllegalArgumentException * if field takes an unpermitted value. */ private void verifyNameProperty(String aName) { boolean nameHasContent = (aName != null) && (!aName.equals("")); if (!nameHasContent) { throw new IllegalArgumentException( "Names must be non-null and non-empty."); } StringCharacterIterator iterator = new StringCharacterIterator(aName); char character = iterator.current(); while (character != StringCharacterIterator.DONE) { boolean isValidChar = (Character.isLetter(character) || Character.isSpaceChar(character) || character == '''); if (isValidChar) { // do nothing } else { String message = "Names can contain only letters, spaces, and apostrophes."; throw new IllegalArgumentException(message); } character = iterator.next(); } } /** * AccountNumber must be non-negative. * * @throws IllegalArgumentException * if field takes an unpermitted value. */ private void validateAccountNumber(int aAccountNumber) { if (aAccountNumber < 0) { String message = "Account Number must be greater than or equal to 0."; throw new IllegalArgumentException(message); } } /** * DateOpened must be after 1970. * * @throws IllegalArgumentException * if field takes an unpermitted value. */ private void validateAccountOpenDate(Date aDateOpened) { if (aDateOpened.getTime() < 0) { throw new IllegalArgumentException( "Date Opened must be after 1970."); } } /** * Always treat deserialization as a full-blown constructor, by validating * the final state of the de-serialized object. */ private void readObject(ObjectInputStream aInputStream) throws ClassNotFoundException, IOException { // always perform the default deserialization first aInputStream.defaultReadObject(); // make defensive copy of the mutable Date field fDateOpened = new Date(fDateOpened.getTime()); // ensure that object state has not been corrupted or tampered with // malicious code verifyUserDetails(); } /** * This is the default implementation of writeObject. Customise if * necessary. */ private void writeObject(ObjectOutputStream aOutputStream) throws IOException { // perform the default serialization for all non-transient, non-static // fields aOutputStream.defaultWriteObject(); } } 现在让我们看看如何在Java中进行序列化和反序列化。Java序列化和反序列化示例package serializationTest; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.Calendar; import java.util.Date; public class TestUserDetails { public static void main(String[] args) { // Create new UserDetails object UserDetails myDetails = new UserDetails("Lokesh", "Gupta", 102825, new Date(Calendar.getInstance().getTimeInMillis())); // Serialization code try { FileOutputStream fileOut = new FileOutputStream("userDetails.ser"); ObjectOutputStream out = new ObjectOutputStream(fileOut); out.writeObject(myDetails); out.close(); fileOut.close(); } catch (IOException i) { i.printStackTrace(); } // deserialization code @SuppressWarnings("unused") UserDetails deserializedUserDetails = null; try { FileInputStream fileIn = new FileInputStream("userDetails.ser"); ObjectInputStream in = new ObjectInputStream(fileIn); deserializedUserDetails = (UserDetails) in.readObject(); in.close(); fileIn.close(); // verify the object state System.out.println(deserializedUserDetails.getFirstName()); System.out.println(deserializedUserDetails.getLastName()); System.out.println(deserializedUserDetails.getAccountNumber()); System.out.println(deserializedUserDetails.getDateOpened()); } catch (IOException ioe) { ioe.printStackTrace(); } catch (ClassNotFoundException cnfe) { cnfe.printStackTrace(); } } } 执行示例,得到结果如下:Lokesh Gupta 102825 Wed Nov 21 15:06:34 GMT+05:30 2012
  • junit5 新特性与使用

    在Java编程测试中junit5 新特性与使用,Java编程,junit5<h2>一、摘要说明</h2>     本JUnit 5教程讲解了如何使JUnit 5改编成java 8编码风格和其他几个特性。了解JUnit5与JUnit 3或4的不同之处。<br />     JUnit 5是Java应用程序中使用最广泛的测试框架。 很久以来,JUnit一直在做得很好。 在之间,JDK 8在java中引起了非常令人兴奋的功能,最引人注目的是lambda表达式。 JUnit 5旨在适应java 8风格的编码和几个其他功能,这就是为什么需要java 8在JUnit 5中创建和执行测试(尽管可以执行用JUnit 3或JUnit 4编写的测试用于向下兼容)。<br />     本文将讲解以下内容: <ol> <li>架构体系</li> <li>环境搭建</li> <li>注解</li> <li>编写动态测试</li> <li>测试套件</li> <li>断言</li> <li>假设</li> <li>向下兼容性</li> <li>回顾总结</li> </ol> <h2>二、JUnit 5架构体系</h2>   与JUnit 4不同,JUnit 5不再是单个库,而是模块化结构的集合,JUnit 5由三个不同的子项目组成<br /> <br /> JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage<br /> <br /> <strong>1.JUnit Platform</strong><br /> JUnit平台作为在JVM上启动测试框架的基础。 它还定义了用于开发在平台上运行的测试框架的TestEngine API。 此外,该平台提供了一个控制台启动器,从命令行启动平台,为Gradle和Maven构建插件以及基于JUnit 4的Runner,用于在平台上运行任何TestEngine。<br /> <strong>2.JUnit Jupiter</strong><br /> JUnit Jupiter是用于在JUnit 5中编写测试和扩展的新编程模型和扩展模型的组合.Jupiter子项目提供了一个用于在平台上运行基于Jupiter的测试的TestEngine。<br /> <strong>3.JUnit Vintage</strong><br /> JUnit Vintage提供了一个用于在平台上运行JUnit 3和JUnit 4的测试的TestEngine。 <h2>三、环境搭建</h2> 引入2个最基础的依赖(即Jupiter引擎依赖关系和平台运行程序依赖关系)在您的maven或gradle项目中使用JUnit 5。<br /> <br /> //pom.xml <pre> <code class="language-xml"><dependency>     <groupId>org.junit.jupiter</groupId>     <artifactId>junit-jupiter-engine</artifactId>     <version>${junit.jupiter.version}</version> </dependency> <dependency>     <groupId>org.junit.platform</groupId>     <artifactId>junit-platform-runner</artifactId>     <version>${junit.platform.version}</version>     <scope>test</scope> </dependency></code></pre> //build.gradle <pre> <code>testRuntime("org.junit.jupiter:junit-jupiter-engine:5.0.0-M4") testRuntime("org.junit.platform:junit-platform-runner:1.0.0-M4")</code></pre> 如果有疑问,请参照官方的build.gradle和pom.xml: <h2>四、JUnit 5注解</h2> JUnit 5提供了以下注释来编写测试。<br /> ANNOTATION    DESCRIPTION<br /> @BeforeEach    注释方法将在测试类中的每个测试方法之前运行。<br /> @AfterEach    注释方法将在测试类中的每个测试方法之后运行。<br /> @BeforeAll    注释方法将在测试类中的所有测试方法之前运行。 此方法必须是静态的。<br /> @AfterAll    注释方法将在测试类中的所有测试方法之后运行。 此方法必须是静态的。<br /> @Test    它用于将方法标记为junit测试<br /> @DisplayName    用于为测试类或测试方法提供任何自定义显示名称<br /> @Disable    它用于禁用或忽略来自测试套件的测试类或方法。<br /> @Nested    用于创建嵌套测试类<br /> @Tag    使用用于测试发现和过滤的标签来标记测试方法或测试类<br /> @TestFactory    标记方法是动态测试的测试工厂 <h2>五、使用JUnit 5中编写动态测试</h2> JUnit 4和JUnit 5在测试写作风格中没有太大变化。 这里是他们的生命周期方法的样本测试。 <pre> <code class="language-java">import org.junit.jupiter.api.AfterAll; import org.junit.jupiter.api.AfterEach; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Disabled; import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.Test; import com.howtodoinjava.junit5.examples.Calculator; public class AppTest { @BeforeAll static void setup(){ System.out.println("@BeforeAll executed"); } @BeforeEach void setupThis(){ System.out.println("@BeforeEach executed"); } @Tag("DEV") @Test void testCalcOne() { System.out.println("======TEST ONE EXECUTED======="); Assertions.assertEquals( 4 , Calculator.add(2, 2)); } @Tag("PROD") @Disabled @Test void testCalcTwo() { System.out.println("======TEST TWO EXECUTED======="); Assertions.assertEquals( 6 , Calculator.add(2, 4)); } @AfterEach void tearThis(){ System.out.println("@AfterEach executed"); } @AfterAll static void tear(){ System.out.println("@AfterAll executed"); } } </code></pre> <h2>六、测试套件</h2> 使用JUnit 5测试套件,您可以将测试扩展到多个测试类和不同的软件包。 JUnit 5提供了两个注解:@SelectPackages和@SelectClasses来创建测试套件。<br /> 要执行该套件,您将使用@RunWith(JUnitPlatform.class)。 <pre> <code class="language-java">​​​​​​​@RunWith(JUnitPlatform.class) @SelectPackages("com.howtodoinjava.junit5.examples") public class JUnit5TestSuiteExample  { }</code></pre> <br /> 此外,您可以使用以下注解来过滤测试包,类甚至测试方法。<br /> 1.@IncludePackages 和 @ExcludePackages 过滤测试包<br /> 2.@IncludeClassNamePatterns 和 @ExcludeClassNamePatterns 过滤测试类<br /> 3.@IncludeTags 和 @ExcludeTags 过滤测试方法 <pre> <code class="language-java">@RunWith(JUnitPlatform.class) @SelectPackages("com.howtodoinjava.junit5.examples") @IncludePackages("com.howtodoinjava.junit5.examples.packageC") @ExcludeTags("PROD") public class JUnit5TestSuiteExample  { }</code></pre> <h2>七、Junit5中的断言</h2>   断言有助于使用测试用例的实际输出验证预期输出。 为了保持简单,所有JUnit Jupiter断言是org.junit.jupiter.Assertions类中的静态方法,例如 assertEquals(),assertNotEquals()。 <pre> <code class="language-java">void testCase() { //Test will pass Assertions.assertNotEquals(3, Calculator.add(2, 2)); //Test will fail Assertions.assertNotEquals(4, Calculator.add(2, 2), "Calculator.add(2, 2) test failed"); //Test will fail Supplier<String> messageSupplier = ()-> "Calculator.add(2, 2) test failed"; Assertions.assertNotEquals(4, Calculator.add(2, 2), messageSupplier); }</code></pre> <h2>八、假设</h2>     Assumptions类提供了静态方法来支持基于假设的条件测试执行。 失败的假设导致测试被中止。 无论何时继续执行给定的测试方法没有意义,通常使用假设。 在测试报告中,这些测试将被标记为已通过。<br />     JUnit jupiter Assumptions类有两个这样的方法:putsFalse(),putsTrue()。 <pre> <code class="language-java">public class AppTest { @Test void testOnDev() { System.setProperty("ENV", "DEV"); Assumptions.assumeTrue("DEV".equals(System.getProperty("ENV")), AppTest::message); } @Test void testOnProd() { System.setProperty("ENV", "PROD"); Assumptions.assumeFalse("DEV".equals(System.getProperty("ENV"))); } private static String message () { return "TEST Execution Failed :: "; } }</code></pre> <h2>九、兼容性</h2> JUnit 3或JUnit 4的向下兼容性<br /> <br /> JUnit 4已经在这里了很长时间,并且有许多测试以junit 4写成.JUnit Jupiter还需要支持这些测试。 为此,开发了JUnit Vintage子项目。<br /> <br /> JUnit Vintage提供了一个TestEngine实现,用于在JUnit 5平台上运行基于JUnit 3和JUnit 4的测试。 <h2>十、总结</h2>     JUnit 5还在开发中。 看起来如此令人兴奋,功能丰富。 而现在它被第三方工具和API扩展开放。 作为测试作者,您可能不会觉得有什么不同,但是当您要扩展或尝试开发任何IDE插件时,您会赞美它。<br /> <br />     作为开发人员,您还可以考虑将测试模板添加到eclipse IDE中以提高开发速度。