各類知識彙總

 

1 F:\programme\Java\jdk1.8.0_201\bin>keytool.exe -genkeypair -alias boot -keyalg RSA -keystore e:/boot/boot.key

pwd :boot11 庫密碼和boot對應的密碼

2

F:\programme\Java\jdk1.8.0_201\bin>keytool -importkeystore -srckeystore e:/boot/boot.key -destkeystore e:/boot/boot.key -deststoretype pkcs12

3 springboot 的https的使用：

 

 

4 iconfont.cn 阿里矢量圖集

 

用第二部轉碼後的沒法使用，只能用第一次生成的舊的，

在4 啓動類配置 連接的跳轉方法

springboot2的寫法和 1不同，下面是正確的

   // springboot2 寫法
    @Bean
    public TomcatServletWebServerFactory servletContainer() {
        TomcatServletWebServerFactory tomcat = new TomcatServletWebServerFactory() {
            @Override
            protected void postProcessContext(Context context) {
                SecurityConstraint constraint = new SecurityConstraint();
                constraint.setUserConstraint("CONFIDENTIAL");
                SecurityCollection collection = new SecurityCollection();
                collection.addPattern("/*");
                constraint.addCollection(collection);
                context.addConstraint(constraint);
            }
        };
        tomcat.addAdditionalTomcatConnectors(httpConnector());
        return tomcat;
    }

    @Bean
    public Connector httpConnector() {
        Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
        connector.setScheme("http");
        //Connector監聽的http的端口號
        connector.setPort(8080);
        connector.setSecure(false);
        //監聽到http的端口號後轉向到的https的端口號
        connector.setRedirectPort(8443);
        return connector;
    }

　　

3 Minor GC 和 Full GC有什麼區別？
　　Minor GC：新生代 GC，指發生在新生代的垃圾收集動做，由於 Java 對象大多死亡頻繁，因此 Minor GC 很是頻繁，通常回收速度較快。
　　Full GC：老年代 GC，也叫 Major GC，速度通常比 Minor GC 慢 10 倍以上。

4 Java 內存
　　爲何要將堆內存分區？
　　對於一個大型的系統，當建立的對象及方法變量比較多時，即堆內存中的對象比較多，若是逐一分析對象是否該回收，效率很低。分區是爲了進行模塊化管理，管理不一樣的對象及變量，以提升 JVM 的執

   　　行效率。
　　分代收集算法
　　內存分配有哪些原則？
　　對象優先分配在 Eden

　　大對象直接進入老年代

　　長期存活的對象將進入老年代

　　動態對象年齡斷定

　　空間分配擔保

　　Young Generation Space （採用複製算法）
　　主要用來存儲新建立的對象，內存較小，垃圾回收頻繁。這個區又分爲三個區域：一個 Eden Space 和兩個 Survivor Space。

　　當對象在堆建立時，將進入年輕代的Eden Space。

　　垃圾回收器進行垃圾回收時，掃描Eden Space和A Suvivor Space，若是對象仍然存活，則複製到B Suvivor Space，若是B Suvivor Space已經滿，則複製 Old Gen

　　掃描A Suvivor Space時，若是對象已經通過了幾回的掃描仍然存活，JVM認爲其爲一個Old對象，則將其移到Old Gen。

　　掃描完畢後，JVM將Eden Space和A Suvivor Space清空，而後交換A和B的角色（即下次垃圾回收時會掃描Eden Space和B Suvivor Space。

 

　　Tenure Generation Space（採用標記-整理算法）
　　主要用來存儲長時間被引用的對象。它裏面存放的是通過幾回在 Young Generation Space 進行掃描判斷過仍存活的對象，內存較大，垃圾回收頻率較小。

　　Permanent Space
　　存儲不變的類定義、字節碼和常量等。

 5 一個類展現內存結構模型

package com.example.springbootdemo;

//對象分配原則
//對象優先分配在 Eden
//大對象直接進入老年代
//長期存活的對象將進入老年代
public class JVMModule {

    public static void main(String[] args) {

    }
}
class Memory{
    //永久區
    PemanentSpace pemanentSpace;
    //堆內存區
    HeapSpace heapSpace;
}
class PemanentSpace{

    //字節碼
    Object bytecode;
    //constants常量
    Object constants;
    //
    Object classDefine;
}
//堆內存
class HeapSpace{
    //新生代,
    YoungGenerateSpace youngGenerateSpace;

    //舊生代，也叫old 老年代
    TenureGenerateSpace tenureGenerateSpace;
}
class YoungGenerateSpace{
    //eden 伊甸園
    Object edenSpace;
    //倖存者0
    Object suvivor0space;
    //倖存者1
    Object suvivor1space;
}
//新生代
class TenureGenerateSpace{

}

 

6 jvm參數調優

  根據web （能夠中斷）gui 不可中斷 ，

根據 內存和cpu個數

 來調整

 7 內存參數調優的例子

-XX:+PrintCommandLineFlags 或者jmx 查詢 
 $ java -XX:InitialHeapSize=128m -XX:MaxHeapSize=2g MyApp   縮寫是 Xms Xmx

下面是內存溢出時 保持內存快照，並保存路徑，由於很大，因此須要指定位置， 第三個參數內存溢出時直線shell腳本 cleanup，例如能夠發送郵件
 java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof -XX:OnOutOfMemoryError ="sh ~/cleanup.sh" MyApp

 

 

8 -XX:+PrintCommandLineFlags 或者jmx 查詢 

$ java -XX:InitialHeapSize=128m -XX:MaxHeapSize=2g MyApp 縮寫是 Xms Xmx

下面是內存溢出時 保持內存快照，並保存路徑，由於很大，因此須要指定位置， 第三個參數內存溢出時直線shell腳本 cleanup，例如能夠發送郵件
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/tmp/heapdump.hprof -XX:OnOutOfMemoryError ="sh ~/cleanup.sh" MyApp'''

設置永久區會獨立於 上面 的 maxheap size ，另外再佔內存
java -XX:PermSize=128m -XX:MaxPermSize=256m MyApp

初始緩存，若是發生問題，字節碼會不編譯，速度下降了數量級,
-XX:InitialCodeCacheSize and -XX:ReservedCodeCacheSize

代碼緩存被填滿時讓JVM放棄一些編譯代碼。經過使用-XX:+UseCodeCacheFlushing 這個參數

 

9 阿里和網易開源鏡像站

 你可使用阿里或者網易的鏡像服務器上面的。阿里：https://opsx.alibaba.com/mirror，網易：http://mirrors.163.com/

 

10 測試用抓包工具 fiddler

 

1 swagger
2 @data lombok的用法

　　    1

<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.4</version>
<scope>provided</scope>
</dependency>

 

     2 plugin ,browser response , search lombok, （新版本只有marketplace），install
     3 解決編譯問題
       build,compile, annonation process,default enable
     4 直接開始使用

 

3 bean驗證 完整
4 mongodb
5 分頁 pagehelper-spring-boot-starter
6 shiro
7 jpush
8 quartz distribute
9 miaodi demo
10 email spring boot
11 springboot 配置 lockback 日誌
12 aop 打印日誌方法
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.util.Arrays;

@Aspect
@Component
@Slf4j
public class LogAspectServiceApi {

@Pointcut("execution(public * com.xxxxxx.controller.*.*(..))")
private void controllerAspect() {
}

@Before(value = "controllerAspect()")
public void methodBefore(JoinPoint joinPoint) {
ServletRequestAttributes requestAttributes = (ServletRequestAttributes) RequestContextHolder
.getRequestAttributes();
HttpServletRequest request = requestAttributes.getRequest();
log.info("===============請求內容===============");
try {
log.info("請求地址:" + request.getRequestURL().toString());
log.info("請求方式:" + request.getMethod());
log.info("請求類方法:" + joinPoint.getSignature());
log.info("請求類方法參數:" + Arrays.toString(joinPoint.getArgs()));
} catch (Exception e) {
log.error("ERROR:", e);
}
log.info("===============請求內容===============");
}

@AfterReturning(returning = "o", pointcut = "controllerAspect()")
public void methodAfterReturing(Object o) {
log.info("--------------返回內容----------------");
try {
log.info("Response內容:" + JSONObject.toJSONString(o));
} catch (Exception e) {
log.error("### ERROR:", e);
}
log.info("--------------返回內容----------------");
}
}
13 配置忽略ssl https證書的 resttemplate

import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.ssl.SSLContexts;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.HttpComponentsClientHttpRequestFactory;
import org.springframework.web.client.RestTemplate;

import javax.net.ssl.SSLContext;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;

@Configuration
public class SSLNoUseRestConfig {

/**
* 配置忽略 SSL證書的 resttemplate
*/
@Bean
public RestTemplate restTemplate() throws KeyStoreException, NoSuchAlgorithmException, KeyManagementException {
RestTemplate restTemplate = new RestTemplate(getFactory());
return restTemplate;
}


private HttpComponentsClientHttpRequestFactory getFactory() {
HttpComponentsClientHttpRequestFactory factory = new HttpComponentsClientHttpRequestFactory();
try {
TrustStrategy acceptingTrustStrategy = (x509Certificates, authType) -> true;
SSLContext sslContext = SSLContexts.custom().loadTrustMaterial(null, acceptingTrustStrategy).build();
SSLConnectionSocketFactory connectionSocketFactory = new SSLConnectionSocketFactory(sslContext, new NoopHostnameVerifier());

HttpClientBuilder httpClientBuilder = HttpClients.custom();
httpClientBuilder.setSSLSocketFactory(connectionSocketFactory);
CloseableHttpClient httpClient = httpClientBuilder.build();
factory.setHttpClient(httpClient);
} catch (Exception e) {
e.printStackTrace();
}
return factory;

}
}

View Code

 

14 mongodb
save對象時移除 _class屬性的配置

/**
* 移除 mongo _class 屬性字段
*/
@Configuration
public class MongoDBConfig {

@Autowired
MongoDbFactory mongoDbFactory;
@Autowired
MongoMappingContext mongoMappingContext;

@Bean
public MappingMongoConverter mappingMongoConverter() {

DbRefResolver dbRefResolver = new DefaultDbRefResolver(mongoDbFactory);
MappingMongoConverter converter = new MappingMongoConverter(dbRefResolver, mongoMappingContext);
converter.setTypeMapper(new DefaultMongoTypeMapper(null));

return converter;
}
}

 

15 開啓swagger

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.service.Contact;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

@Bean
public Docket api() {
return new Docket(DocumentationType.SWAGGER_2)
.apiInfo(apiInfo())
.select()
.apis(RequestHandlerSelectors.basePackage("com.xxxxxxxx.controller"))
.paths(PathSelectors.any())
.build();
}

private ApiInfo apiInfo() {
return new ApiInfoBuilder()
.title("my manager")
.description("mydesc")
.termsOfServiceUrl("http://www.ityouknow.com/") //servide network
.version("1.0")
.contact(new Contact("mycompany", "url", "imydata"))
.build();
}
}

 15 極光推送

import cn.jiguang.common.ClientConfig;
import cn.jiguang.common.resp.APIConnectionException;
import cn.jiguang.common.resp.APIRequestException;
import cn.jpush.api.JPushClient;
import cn.jpush.api.push.PushResult;
import cn.jpush.api.push.model.Options;
import cn.jpush.api.push.model.Platform;
import cn.jpush.api.push.model.PushPayload;
import cn.jpush.api.push.model.audience.Audience;
import cn.jpush.api.push.model.notification.AndroidNotification;
import cn.jpush.api.push.model.notification.IosNotification;
import cn.jpush.api.push.model.notification.Notification;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class JigPushUtil {
	
    private static final Logger log = LoggerFactory.getLogger(JigPushUtil.class);
    
    private static String masterSecret = "abc";
    private static String appKey = "def";
    
    public static void jiguangPush(String alias, String message){
        try {
            PushResult result = push(String.valueOf(alias),message);
            log.info("result?"成功":"失敗"));
        } catch (Exception e) {
            log.error("發生錯誤："+e.toString());
        }
    }
    
 
    private static PushPayload buildPushObject_android_ios_alias_alert(String alias,String message){
        return PushPayload.newBuilder()
                .setPlatform(Platform.all())
                .setAudience(Audience.alias(alias))
                .setNotification(Notification.newBuilder()
                        .addPlatformNotification(AndroidNotification.newBuilder()
                                .addExtra("type", "infomation")
                                .setAlert(message)
                                .build())
                        .addPlatformNotification(IosNotification.newBuilder()
                                .addExtra("type", "infomation")
                                .setAlert(message)
                                .build())
                        .build())
                .setOptions(Options.newBuilder()
                        .setApnsProduction(true)//true-推送生產環境 false-推送開發環境（測試使用參數）
                        .setTimeToLive(90)//消息在JPush服務器的失效時間
                        .build())
                .build();
    }


    private static PushResult push(String alias,String message){
        try {
            ClientConfig clientConfig = ClientConfig.getInstance();
            JPushClient jpushClient = new JPushClient(masterSecret, appKey, null, clientConfig);
            PushPayload payload = buildPushObject_android_ios_alias_alert(alias,message);
            PushResult result = jpushClient.sendPush(payload);
            jpushClient.close();
            return result;
        } catch (APIConnectionException e) {
            log.error("Connection error. Should retry later. ", e);
            return null;
        } catch (APIRequestException e) {
            log.error("Error response from JPush server. Should review and fix it. ", e);
            return null;
        }catch (Exception e) {
        	log.error("Failed to send push to app ",e);
        	return null;
        }    
    }
    public static void main(String[] args) {
    	jiguangPush("123","mysesssge");
	}

　　

 

上次 nginx 配置出錯由於，

1 tomcat下配置了本地的rabbitmq，放到服務器找不到了
2 重啓nginx須要使用 進程不是服務來關閉，當時沒有關閉成功

 

vscode 快捷鍵大全

 

 

 

20 使用winscp 默認用 祕鑰登陸 配置 ppk的方法

默認使用putty登陸

 

winscp 怎麼用私鑰文件登陸的，以.ppk結尾的密鑰文件

 

Winscp默認用賬號密碼登陸，用私鑰文件登陸須要在高級選項裏面的SSH--驗證裏面選擇文件。

Winscp使用的是putty做爲SSH登陸工具，而puttygen所生成的是以.ppk結尾的密鑰文件。

若是是pub類型的須要轉換爲putty類型的，文件類型裏選擇全部文件，選擇密鑰文件會提示你是否轉換，按提示操做轉換保存後就會自動選擇轉換後的.ppk密鑰文件了。

 

 jdk8的新特性之時間

 

import java.time.ZonedDateTime;
import java.time.ZoneId;
 
public class Java8Tester {
   public static void main(String args[]){
      Java8Tester java8tester = new Java8Tester();
      java8tester.testZonedDateTime();
   }
    
   public void testZonedDateTime(){
    
      // 獲取當前時間日期
      ZonedDateTime date1 = ZonedDateTime.parse("2015-12-03T10:15:30+05:30[Asia/Shanghai]");
      System.out.println("date1: " + date1);
        
      ZoneId id = ZoneId.of("Europe/Paris");
      System.out.println("ZoneId: " + id);
        
      ZoneId currentZone = ZoneId.systemDefault();
      System.out.println("當期時區: " + currentZone);
   }

 

jdk8 技術總結

 

1 使用 google工具類實現一行添加數據新建list
com.google.common.collect.Lists

2 list 的 foreach的兩種方式
：：雙冒號和 拉姆達表達式
3 求和 ,過濾，跳過等操做

 

 

import com.google.common.collect.Lists;
import org.junit.Test;

import java.lang.annotation.*;
import java.nio.charset.StandardCharsets;
import java.time.*;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
import java.util.function.Supplier;

/**
 *
 * @ClassName:JDK8_features
 * @Description:JDK8新特性
 * @author diandian.zhang
 * @date 2017年4月17日上午9:13:24
 */
public class JDK8_features {

    public List<Integer> list = Lists.newArrayList(1,2,3,4,5,6,7,8,9,10);

    /**
     * 1.Lambda表達式
     */
    @Test
    public void testLambda(){
        list.forEach(System.out::println);
        list.forEach(e -> System.out.println("方式二："+e));
    }

    /**
     * 2.Stream函數式操做流元素集合
     */
    @Test
    public void testStream(){
        List<Integer> nums = Lists.newArrayList(1,1,null,2,3,4,null,5,6,7,8,9,10);
        System.out.println("求和："+nums
                .stream()//轉成Stream
                .filter(team -> team!=null)//過濾
                .distinct()//去重
                .mapToInt(num->num*2)//map操做
                .skip(2)//跳過前2個元素
                .limit(4)//限制取前4個元素
                .peek(System.out::println)//流式處理對象函數
                .sum());//
    }

    /**
     * 3.接口新增：默認方法與靜態方法
     *  default 接口默認實現方法是爲了讓集合類默認實現這些函數式處理，而不用修改現有代碼
     *  （List繼承於Iterable<T>，接口默認方法沒必要須實現default forEach方法）
     */
    @Test
    public void testDefaultFunctionInterface(){
        //能夠直接使用接口名.靜態方法來訪問接口中的靜態方法
        JDK8Interface1.staticMethod();
        //接口中的默認方法必須經過它的實現類來調用
        new JDK8InterfaceImpl1().defaultMethod();
        //多實現類，默認方法重名時必須複寫
        new JDK8InterfaceImpl2().defaultMethod();
    }

    public class JDK8InterfaceImpl1 implements JDK8Interface1 {
        //實現接口後，由於默認方法不是抽象方法，重寫/不重寫都成！
//        @Override
//        public void defaultMethod(){
//            System.out.println("接口中的默認方法");
//        }
    }

    public class JDK8InterfaceImpl2 implements JDK8Interface1,JDK8Interface2 {
        //實現接口後，默認方法名相同，必須複寫默認方法
        @Override
        public void defaultMethod() {
            //接口的
            JDK8Interface1.super.defaultMethod();
            System.out.println("實現類複寫重名默認方法！！！！");
        }
    }

    /**
     * 4.方法引用,與Lambda表達式聯合使用
     */
    @Test
    public void testMethodReference(){
        //構造器引用。語法是Class::new，或者更通常的Class< T >::new，要求構造器方法是沒有參數；
        final Car car = Car.create( Car::new );
        final List< Car > cars = Arrays.asList( car );
        //靜態方法引用。語法是Class::static_method，要求接受一個Class類型的參數；
        cars.forEach( Car::collide );
        //任意對象的方法引用。它的語法是Class::method。無參，全部元素調用；
        cars.forEach( Car::repair );
        //特定對象的方法引用，它的語法是instance::method。有參，在某個對象上調用方法，將列表元素做爲參數傳入；
        final Car police = Car.create( Car::new );
        cars.forEach( police::follow );
    }

    public static class Car {
        public static Car create( final Supplier< Car > supplier ) {
            return supplier.get();
        }

        public static void collide( final Car car ) {
            System.out.println( "靜態方法引用 " + car.toString() );
        }

        public void repair() {
            System.out.println( "任意對象的方法引用 " + this.toString() );
        }

        public void follow( final Car car ) {
            System.out.println( "特定對象的方法引用 " + car.toString() );
        }
    }

    /**
     * 5.引入重複註解
     * 1.@Repeatable
     * 2.能夠不用之前的「註解容器」寫法，直接寫2次相同註解便可
     *
     * Java 8在編譯器層作了優化，相同註解會以集合的方式保存，所以底層的原理並無變化。
     */
    @Test
    public void RepeatingAnnotations(){
        RepeatingAnnotations.main(null);
    }

    /**
     * 6.類型註解
     * 新增類型註解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER（在Target上）
     *
     */
    @Test
    public void ElementType(){
        Annotations.main(null);
    }

    /**
     * 7.最新的Date/Time API (JSR 310)
     */
    @Test
    public void DateTime(){
        //1.Clock
        final Clock clock = Clock.systemUTC();
        System.out.println( clock.instant() );
        System.out.println( clock.millis() );

        //2. ISO-8601格式且無時區信息的日期部分
        final LocalDate date = LocalDate.now();
        final LocalDate dateFromClock = LocalDate.now( clock );

        System.out.println( date );
        System.out.println( dateFromClock );

        // ISO-8601格式且無時區信息的時間部分
        final LocalTime time = LocalTime.now();
        final LocalTime timeFromClock = LocalTime.now( clock );

        System.out.println( time );
        System.out.println( timeFromClock );

        // 3.ISO-8601格式無時區信息的日期與時間
        final LocalDateTime datetime = LocalDateTime.now();
        final LocalDateTime datetimeFromClock = LocalDateTime.now( clock );

        System.out.println( datetime );
        System.out.println( datetimeFromClock );

        // 4.特定時區的日期/時間，
        final ZonedDateTime zonedDatetime = ZonedDateTime.now();
        final ZonedDateTime zonedDatetimeFromClock = ZonedDateTime.now( clock );
        final ZonedDateTime zonedDatetimeFromZone = ZonedDateTime.now( ZoneId.of( "America/Los_Angeles" ) );

        System.out.println( zonedDatetime );
        System.out.println( zonedDatetimeFromClock );
        System.out.println( zonedDatetimeFromZone );

        //5.在秒與納秒級別上的一段時間
        final LocalDateTime from = LocalDateTime.of( 2014, Month.APRIL, 16, 0, 0, 0 );
        final LocalDateTime to = LocalDateTime.of( 2015, Month.APRIL, 16, 23, 59, 59 );

        final Duration duration = Duration.between( from, to );
        System.out.println( "Duration in days: " + duration.toDays() );
        System.out.println( "Duration in hours: " + duration.toHours() );
    }

    /**
     * 8.新增base64加解密API
     */
    @Test
    public void testBase64(){
        final String text = "就是要測試加解密！！abjdkhdkuasu!!@@@@";
        String encoded = Base64.getEncoder()
                .encodeToString( text.getBytes( StandardCharsets.UTF_8 ) );
        System.out.println("加密後="+ encoded );

        final String decoded = new String(
                Base64.getDecoder().decode( encoded ),
                StandardCharsets.UTF_8 );
        System.out.println( "解密後="+decoded );
    }

    /**
     * 9.數組並行（parallel）操做
     */
    @Test
    public void testParallel(){
        long[] arrayOfLong = new long [ 20000 ];
        //1.給數組隨機賦值
        Arrays.parallelSetAll( arrayOfLong,
                index -> ThreadLocalRandom.current().nextInt( 1000000 ) );
        //2.打印出前10個元素
        Arrays.stream( arrayOfLong ).limit( 10 ).forEach(
                i -> System.out.print( i + " " ) );
        System.out.println();
        //3.數組排序
        Arrays.parallelSort( arrayOfLong );
        //4.打印排序後的前10個元素
        Arrays.stream( arrayOfLong ).limit( 10 ).forEach(
                i -> System.out.print( i + " " ) );
        System.out.println();
    }

    /**
     * 10.JVM的PermGen空間被移除：取代它的是Metaspace（JEP 122）元空間
     */
    @Test
    public void testMetaspace(){
        //-XX:MetaspaceSize初始空間大小，達到該值就會觸發垃圾收集進行類型卸載，同時GC會對該值進行調整
        //-XX:MaxMetaspaceSize最大空間，默認是沒有限制
        //-XX:MinMetaspaceFreeRatio在GC以後，最小的Metaspace剩餘空間容量的百分比，減小爲分配空間所致使的垃圾收集
        //-XX:MaxMetaspaceFreeRatio在GC以後，最大的Metaspace剩餘空間容量的百分比，減小爲釋放空間所致使的垃圾收集
    }

}

interface JDK8Interface1 {

    //1.接口中能夠定義靜態方法了
    public static void staticMethod(){
        System.out.println("接口中的靜態方法");
    }

    //2.使用default以後就能夠定義普通方法的方法體了
    public default void defaultMethod(){
        System.out.println("接口中的默認方法");
    }
}

interface JDK8Interface2 {

    //接口中能夠定義靜態方法了
    public static void staticMethod(){
        System.out.println("接口中的靜態方法");
    }
    //使用default以後就能夠定義普通方法的方法體了
    public default void defaultMethod(){
        System.out.println("接口中的默認方法");
    }
}

/**
 *
 * @ClassName:RepeatingAnnotations
 * @Description:重複註解@Repeatable
 * @author diandian.zhang
 * @date 2017年3月31日下午3:48:13
 */
class RepeatingAnnotations {
    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    public @interface Filters {
        Filter[] value();
    }

    @Target( ElementType.TYPE )
    @Retention( RetentionPolicy.RUNTIME )
    @Repeatable( Filters.class )
    public @interface Filter {
        String value();
        String value2();
    };

    @Filter( value="filter1",value2="111" )
    @Filter( value="filter2", value2="222")
    //@Filters({@Filter(  value="filter1",value2="111" ),@Filter(  value="filter2", value2="222")}).注意：JDK8以前：1.沒有@Repeatable2.採用本行「註解容器」寫法
    public interface Filterable {
    }

    public static void main(String[] args) {
        //獲取註解後遍歷打印值
        for( Filter filter: Filterable.class.getAnnotationsByType( Filter.class ) ) {
            System.out.println( filter.value() +filter.value2());
        }
    }
}

/**
 *
 * @ClassName:Annotations
 * @Description:新增類型註解:ElementType.TYPE_USE 和ElementType.TYPE_PARAMETER（在Target上）
 * @author diandian.zhang
 * @date 2017年3月31日下午4:39:57
 */
class Annotations {
    @Retention( RetentionPolicy.RUNTIME )
    @Target( { ElementType.TYPE_USE, ElementType.TYPE_PARAMETER } )
    public @interface NonEmpty {
    }

    public static class Holder< @NonEmpty T > extends @NonEmpty Object {
        public void method() throws @NonEmpty Exception {
        }
    }

    public static void main(String[] args) {
        final Holder< String > holder = new @NonEmpty Holder< String >();
        @NonEmpty Collection< @NonEmpty String > strings = new ArrayList<>();
    }
}

 

 

1 echart數據纔會刷新，須要設置true
this.currchart1=echarts.init(document.getElementById('chart1')).setOption(option,true);
2 獲取屬性個數
Object.keys(abc).length
3 遍歷 對象的方法
abc={a:1,b:2};
{a: 1, b: 2}
for(k in abc){console.log(k)}
VM158:1 a
VM158:1 b
4 使用parseFloat 解決 數字字符串相加問題
parseFloat(d.doorClose_average_vibrationX)+parseFloat(d.doorClose_envelope_vibrationX)]

5 使用mongodb原生的in的例子
BasicDBList values = new BasicDBList();
values.add(30);
values.add(50);
queryCondition.put("a", new BasicDBObject("$in", values));
或用第二種方法
condition.put("loadClass",new BasicDBObject("$in","我是java數組"));

1 jdk自帶的 經常使用命令
jad xxx.class
會生成 反編譯的 文件xxxx
2 jmap 進程對 內存的使用狀況
jmap -histo:live 2743
jmap 2743
jmap -heap 38574
3 jstat 對資源和性能的監控，包括老生代，新生代等等所有都有

 

 

 

4 jstack 打印線程堆棧快照信息，分析現場等待，思索問題

 

1.想拷貝別人項目到本身賬號下就fork一下。
2.持續關注別人項目更新就star一下
3.watch是設置接收郵件提醒的。

好的方式

  好用的英文字體

Times New Roman

 5 spring boot 郵件發送方法

 

1 依賴
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-mail</artifactId>
</dependency>
2 郵件配置
 
spring.mail.host=smtp.gmail.com
spring.mail.username=<your email username>
spring.mail.password=<your email password>
spring.mail.default-encoding=utf-8

#If you use Gmail, the follow two lines are necessary
spring.mail.properties.mail.smtp.socketFactory.port = 465
spring.mail.properties.mail.smtp.socketFactory.class = javax.net.ssl.SSLSocketFactory

3 

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest
public class DemoApplicationTests {

    @Test
    public void contextLoads() {
        sendSimpleMail("","title","content");
    }


  @Value("${spring.mail.username}")
    private String from;

    @Autowired
    private JavaMailSender mailSender;

    public void sendSimpleMail(String to, String subject, String content) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo("xxxxx@qq.com");
        message.setSubject(subject);
        message.setText(content);
        message.setFrom(from);

        mailSender.send(message);
    }
}

 

 1 mqtt 打debug調試會致使mqtt連接中斷（由於超時？）

踩坑總結

nknown custom element did you register the component correc 由於沒有註冊組件
少計算了一個data，致使數據爲空，
少計算了 flag爲ture致使都沒數據
最終使用合併的數據列
很重要須要選好時機

this.$nextTick(function(){
this.drawCharts3D(this.chartParams);//畫3d圖
return;
})

 

new Date().toJSON()
"2019-08-21T21:46:03.555Z"

cst 和sgt 時區相同

EEE MMM dd HH:mm:ss zzz yyyy

BaseCalendar.Date date = normalize();
TimeZone zi = date.getZone();
if (zi != null) {
sb.append(zi.getDisplayName(date.isDaylightTime(), TimeZone.SHORT, Locale.US)); // zzz
} else {
sb.append("GMT");
}

ZZZ是 +0800
2019-08-22 05:59:45 +0800

zzz 是CST/SGT

只用 三行 就夠了 simpledateformat，能夠格式化爲字符串，也可解析字符串爲時間

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss zzz");
System.out.println(format.format(new Date()));
System.out.println("============"+format.parse("2019-04-03 03:22:11 CST"));
2019-08-22 06:16:45 CST
============Wed Apr 03 03:22:11 CST 2019

1 時間出錯緣由居然是由於 日期自動轉爲了java的date到mongo的 timestamp，致使再轉出來的時候已經格式不匹配了
沒法long轉爲 date

shiro 攔截器的正常思路：

 

loginservice新添加

userservice添加 @lazy

handler的攔截器

HandlerInterceptorAdapter 繼承 實現preHandler方法

功能有
1 判讀若是不是Handler handler不是 HandlerMethod 類型映射的方法直接放過
2 若是是swagger直接放過
3 若是是errorhtml直接拋出異常被捕獲後html跳轉
4 若是是errorhtml直接放過
5 從header獲取等3個地方獲取token
從Authorization獲取，
從api_key獲取（考慮萬一是從swagger也用token），兩個key均可以
若是header的爲空，從token獲取，key是token
若是cookie爲空從參數獲取 key爲token
6 判斷爲空
des解密
判斷爲空
解析字符串爲Token對象
token包含了type是否爲web和手機
若是手機不退出就用於在線，判讀除了web的都是true
web須要判斷時間的有效性，默認12小時有效
7 再次檢測token是否爲空和保存的user是否爲空
8 再次檢測傳遞的user是否爲空
9 檢測token在redis中存儲是否過時，經過判斷token_開頭的是否存在
redis.get(token_+userid)的方式
10 再次檢測傳遞的token和redistoken是否一致，判斷設備
11 查詢user是否在db中存在，沒有從新登陸，有的話狀態爲2 從新登陸
12 沒明白 token_expires_的用法

 cron的表達式使用

Quartz使用相似於Linux下的Cron表達式定義時間規則，Cron表達式由6或7個由空格分隔的時間字段組成，如表1所示：

表1 Cron表達式時間字段

位置

時間域名

容許值

容許的特殊字符

1

秒

0-59

, - * /

2

分鐘

0-59

, - * /

3

小時

0-23

, - * /

4

日期

1-31

, - * ? / L W C

5

月份

1-12

, - * /

6

星期

1-7

, - * ? / L C #

7

年(可選)

空值1970-2099

, - * /

Cron表達式的時間字段除容許設置數值外，還可以使用一些特殊的字符，提供列表、範圍、通配符等功能，細說以下：

●星號(*)：可用在全部字段中，表示對應時間域的每個時刻，例如，*在分鐘字段時，表示「每分鐘」；

●問號（?）：該字符只在日期和星期字段中使用，它一般指定爲「無心義的值」，至關於點位符；

●減號(-)：表達一個範圍，如在小時字段中使用「10-12」，則表示從10到12點，即10,11,12；

●逗號(,)：表達一個列表值，如在星期字段中使用「MON,WED,FRI」，則表示星期一，星期三和星期五；

●斜槓(/)：x/y表達一個等步長序列，x爲起始值，y爲增量步長值。如在分鐘字段中使用0/15，則表示爲0,15,30和45秒，而5/15在分鐘字段中表示5,20,35,50，你也可使用*/y，它等同於0/y；

 

 

在恰當的斷字點進行換行：

p.test {word-break:hyphenate;}
break-all 自適應 範圍
通常數據庫鏈接 後綴
?serverTimezone=GMT%2B8&zeroDateTimeBehavior=convertToNull

設置顏色的幾種方式 
background-color:rgb(255,0,255);
border:1px solid rgb(112, 197, 236);

 =========================》》》》》》》》》》》》》》》》》》》》》》

1 三大特性： CAS

  高併發，高可見，高性能， 悲觀鎖安全，每次來都必須佔用鎖， select for update，這樣致使低性能

  樂觀鎖，先相信，而後比較 version或者 時間戳，用的多，可是高併發時錯誤率低，由於修改的多，這個時缺點，瑕不掩瑜

 

 

 

 

idea 熱部署的四個步驟
查看端口對應進程號
netstat -ano |findstr 9091

窗口變化觸發事件
addEventListener('resize',function(){alert(1)})

 

 

 

 openssl的使用方法：

 

 

----------------------------

openssl 用法：

d:\openssl>set RANDFILE=d:\openssl\.rnd
d:\openssl>set OPENSSL_CONF=d:\openssl\OpenSSL-Win64\bin\openssl.cfg

先要進去 openssl.exe

生成私鑰
genrsa -out ca.key 2048

根據私鑰生成公鑰
rsa -in ca.key -out ca.key.public

根據私鑰生成證書