佳林L

 

SpringBoot

1：Spring Boot簡介

簡化Spring應用開發的一個框架。

整個Spring技術棧的一個大整合。

JavaEE開發的一站式解決方案。

2：微服務

2014，martin fowler

微服務：架構風格(服務微化)

一個應用應該是一組小型服務；可以通過Http的方式進行互通。

每一個功能元素最終都是一個可獨立替換和獨立升級的軟件單元。

3：YAML語法

一，基本語法

K：V：表示一對鍵值對(空格必須有)

以空格的縮進來控制層級關系；只要是左對齊的一列數據，都是同一個層級的。

server:
    port: 8081
    path: /hello

屬性和值大小寫敏感的。

 

二，值的寫法

● 字面量：普通的值(數字，字符串，布爾)

k：v：字面直接來寫；

字符串默認不用加上單引號或者雙引號；

""：雙引號；不會轉義字符串里面的特殊字符，特殊字符會作為本身想表示的意思。

name："zhangsan \n lisi"：輸出：zhangsan 換行 lisi

''：單引號；會轉義特殊字符，特殊字符最終只是一個普通的字符串數據。

name："zhangsan \n lisi"：輸出：zhangsan \n lisi

 

● 對象：Map(屬性和值)(鍵值對)

k：v：在下一行來寫對象的屬性和值的關系；注意縮進

friends：
    lastname：zhangsan
    age：20

行內寫法：

friends：{lastname：zhangsan,age：20}

 

● 數組：(List，Set)

用 - 值表示數組中的一個元素

pets:
    - cat
    - dog
    - pig

行內寫法：

pets:[cat,dog,pig]

 

三，配置文件值注入

配置文件：

persen:
    lastname: zhangsan
    age: 18
    boss: false
    birth: 2017/12/12
    maps: {k1: v1,k2: v2}
    list:
      - list
      - zhaoliu
    dog:
      name: xiaogou
      age: 20

javaBean：

/**
 * 將配置文件中配置的每一個屬性的值，映射到這個組件中
 * @ConfigurationProperties：告訴SpringBoot將本類中所有屬性和配置文件中相關的配置進行綁定
 * (prefix = "persen")：配置文件中那個下面的所有屬性進行一一映射
 * 只有這個組件是容器中的組件，才能使用容器提供的功能@ConfigurationProperties
 */
@ConfigurationProperties(prefix = "persen")
@Component
public class Persen {
    private String lastname;
    private Integer age;
    private boolean boss;
    private Date birth;
?
    private Map<String,Object> maps;
    private List<Object> list;
    private Dog dog;
?

 

我們可以導入配置文件處理器，以后編寫配置就有提示了：

        <!-- 導入配置文件處理器，配置文件進行綁定就會有提示-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

1：@value獲取值和@ConfigurationProperties獲取值比較：

	@ConfigurationProperties	@value
功能	批量注入配置文件中的屬性	一個個指定
松散綁定(松散語法)	支持	不支持
SpEl	不支持	支持
JSR303數據校驗	支持	不支持
復雜類型封裝	支持	不支持

配置文件yml和properties他們都能獲取到值；

如果說，我們只是在某個業務邏輯中需要獲取一下配置文件中的某項值，使用@value；

如果說，我們專門編寫了一個javaBean來和配置文件進行映射，我們就直接使用@ConfigurationProperties；

 

2：@PropertySource和@ImportResource：

@PropertySource：加載指定的配置文件。

@PropertySource(value = {"classpath:persen.properties"})
@ConfigurationProperties(prefix = "persen")
@Component
public class Persen {
?
    private String lastname;
    private Integer age;
    private boolean boss;
    private Date birth;
?
    private Map<String,Object> maps;
    private List<Object> list;
    private Dog dog;
?

@ImportResource：導入Spring的配置文件，讓配置文件里面的內容生效。

Spring Boot里面沒有Spring的配置文件，我們自己編寫的配置文件也不能自動識別。

想讓Spring的配置文件有效，加載進來；把他@ImportResource標致在配置類上。

@ImportResource(locations = {"classpath:beans.xml"})
導入Spring的配置文件讓其生效

 

Spring Boot推薦給容器添加組件的方式：推薦使用全注解的方式；

● 使用@Bean給容器中添加組件：

/**
 * @Configuration：指明當前類是一個配置類，就是來替代之前的Spring配置文件。
 * 在配置文件中用<bean></bean>標簽添加組件
 */
@Configuration
public class MyappConfig {
?
    /**
     *將方法的返回值添加到容器中，容器中這個組件默認的id就是方法名
     */
    @Bean
    public HelloService helloService(){
        return new HelloService();
    }

4：整合SpringData JPA(java持久層API)

1），編寫一個實體類(bean)和數據表進行映射，并且配置好映射關系。

/**
 * 使用JPA注解配置映射關系
 */
@Entity //告訴JPA這是一個實體類(和數據表映射的類)
@Table(name="u_user") //@Table來指定和那個數據表對應;如果省略,默認表名就是user
public class User {
?
    @Id //這是一個主鍵
    @GeneratedValue(strategy= GenerationType.IDENTITY) //自增主鍵
    private Integer id;
?
    @Column(name="name",length = 50) //這是和數據表對應的一個列
    private String name;
?
    @Column //省略默認列名就是屬性名
    private String email;
}
?

2)，編寫一個Dao接口來操作實體類對應的數據表(Repository)；

//繼承JpaRepository來完成對數據庫的操作
public interface RepositoryDao extends JpaRepository<User, Integer> {
}

3)，基本的配置；

spring:
  jpa:
    hibernate:
      #更新或者創建數據表結構
      ddl-auto: update
      #在控制臺顯示sql
    show-sql: true

Hibernate：

1)，是一個全自動的ORM，與數據庫無關，面向對象的。SpringDateJPA --->封裝了Hibernate --->JDKAPI

hibernate 對象有三個狀態：

1，瞬時狀態 ---> 剛創建出來的Hibernate無任何關聯與數據庫無任何關聯。

2，持久化狀態 ---> 被hibernate管理，并且session沒有關閉，內存中存在數據庫中也存在，如果內存中的數據發送變化會去同步數據庫的數據。

3，游離狀態 ---> session關閉了，數據庫中可能存在。

ORM關系對象映射中：

1)，OneToOne。

2)，OneToMany(默認使用懶加載)。

3)，ManyToOne(默認使用急加載)。

4)，ManyToMany(兩個oneTomany)。

 

5：Spring-boot啟動流程；

幾個重要的事件回調機制：

配置在META-INF/spring.factories

ApplicationContextInitializer

ApplicationRunListener

只需要放在ioc容器中

ApplicationRunner

CommandLineRunner

1），創建SpringApplication對象。

public static ConfigurableApplicationContext run(Object[] sources, String[] args) {
        return new SpringApplication(sources).run(args);
    }

    //調用此方法創建SpringApplication對象
    public SpringApplication(Object... sources) {
            initialize(sources);
        }
?
    private void initialize(Object[] sources) {
        if (sources != null && sources.length > 0) {
            //保存主配置類
            this.sources.addAll(Arrays.asList(sources));
        }
        //判斷當前是否是web應用
        this.webEnvironment = deduceWebEnvironment();
        //從類路徑下找到META-INF/Spring.factories配置的所有ApplicationContextInitializer;然后保存起來；
        setInitializers((Collection) getSpringFactoriesInstances(
                ApplicationContextInit.class));
        //從類路徑下找到META-INF/Spring.factories配置的所有ApplicationLtener
        setListeners((Collection)        getSpringFactoriesInstances(ApplicationListener.class));
        //從多個配置類中找到有main方法的主配置類
        this.mainApplicationClass = deduceMainApplicationClass();
    }

2），運行run方法。

    public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        FailureAnalyzers analyzers = null;
        configureHeadlessProperty();
        
        //獲取SpringApplicationRunListenners；從類路徑下META-INF/spring.factories
        SpringApplicationRunListeners listeners = getRunListeners(args);
        //回調所有獲取的SpringApplicationRunListenner.starting方法
        listeners.starting();
        try {
            //封裝命令行參數
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(
                    args);
            //準備環境
            ConfigurableEnvironment environment = prepareEnvironment(listeners,
                    applicationArguments);
            //創建環境完成后回調SpringApplicationRunListenners.environmentPrepared()表示環境準備完成
            
            Banner printedBanner = printBanner(environment);
            //創建ApplicationContext；決定創建web的ioc還是普通的ioc容器。
            context = createApplicationContext();
            analyzers = new FailureAnalyzers(context);
           
            
            //準備上下文環境；將environment保存在ioc中；而且applyInitializers()；
            //applyInitializers():回調之前保存的所有ApplicationContextInitializer的initialize()方法
            //回調之前保存好的所有SpringApplicationRunListenner的contextPrepared()方法；
            //preparedContext運行完成以后回調所有的SpringApplicationRunListenner的contextLoaded()方法；
            prepareContext(context, environment, listeners, applicationArguments,
                    printedBanner);
            
            //刷新容器，ioc容器初始化(如果是web應用還會創建嵌入式的Tomcat)；
            refreshContext(context);
            
            //從ioc容器中獲取所有的ApplicationRunner和CommandLineRunner進行回調；
            //ApplicationRunner先回調
            afterRefresh(context, applicationArguments);
            
            //所有的SpringApplicationRunListener回調fineshed()方法；
            listeners.finished(context, null);
            stopWatch.stop();
            if (this.logStartupInfo) {
                new StartupInfoLogger(this.mainApplicationClass)
                        .logStarted(getApplicationLog(), stopWatch);
            }
            //整個Spring-boot啟動完成之后返回啟動的ioc容器
            return context;
        }
        catch (Throwable ex) {
            handleRunFailure(context, listeners, analyzers, ex);
            throw new IllegalStateException(ex);
        }
    }

6：Spring-Boot高級-消息

1），消息隊列主要有兩種形式的目的地：

①：隊列(queue)：點對點消息通信。

點對點式：消息發送者發送消息，消息代理將其放在一個隊列中，消息接受者從隊列中獲取消息內容，消息讀取后被移除。

②：主題(topic)：發布(publish)/訂閱(subscribe)消息通信。

發布訂閱式：發布者發送消息到主題，多個訂閱者訂閱這個主題，那么就會在消息到達時同時收到消息。

2），JMS(Java Message Service)Java消息服務：

基于JVM消息代理的規范。ActiveMQ，HornetMQ是JMS實現。

3），AMQP(Advanced Message Queuing Protocol)高級消息隊列協議：

RabbitMQ是AMQP的實現。

JMS和AMQP的區別：

JMS是java的api，不支持跨語言，跨平臺，提供了2種消息模型：點對點和發布與訂閱。它支持消息類型：文本消息，集合消息，對象消息。

AMQP是網絡線級協議，它是支持跨語言，跨平臺的，提供了5種消息模型：direct，fanout，topic,headers,system。它只支持二進制消息類型。

Message(消息)：

它由消息頭和消息體組成的。消息體是不透明的，消息頭則由一系列的可選屬性組成，這些屬性包括routing-key(路由鍵)，priority(相對于其他消息的優先權)，delivery-mode(指出該消息可能需要持久性存儲)等。

Exchange(交換器)：

四種類型：

1），direct：它是根據消息中的路由鍵派發給指定的一個消息隊列，它是完全匹配，單播的模式。

2），Fanout：每個發到fanout交換器的消息都會分到所有綁定的隊列上去。

3），Topic：根據路由鍵的規則模糊匹配有選擇性的綁定的隊列上去，它同樣也會識別兩個通配符：“#”和“*”。# 匹配0個或多個單詞， * 匹配一個單詞。

7：thymeleaf模板

1），后綴是html，也就是可以直接打開，也就是前端人員可以直接參與開發。

2），最終都是后臺輸出的完整的HTML。

3），后臺會替換HTML中的占位符，保留HTML標簽，CSS樣式，JS代碼。

8：配置虛擬路徑加攔截器加Swagger2

?
// 配置虛擬路徑
@Configuration
public class WebConfig implements WebMvcConfigurer {
?
    @Autowired
    private Myinterceptor myinterceptor;
?
?
    /**
     *  放行靜態資源 或 映射虛擬路徑
     */
    @Override
    public void addResourceHandlers(ResourceHandlerRegistry registry) {
        
        // Swagger2
        registry.addResourceHandler("/swagger-ui.html")
                .addResourceLocations("classpath:/META-INF/resources/")
                .setCacheControl(CacheControl.maxAge(1, TimeUnit.HOURS).cachePublic());
        registry.addResourceHandler("/webjars/**")
                .addResourceLocations("classpath:/META-INF/resources/webjars/")
                .setCacheControl(CacheControl.maxAge(1, TimeUnit.HOURS).cachePublic());
        
        // 配置圖片虛擬路徑
        registry.addResourceHandler("/t/**")
                .addResourceLocations("file:D:/iderUtil/Imgproject_Save/");
?
        // 放行 static下所有靜態資源
        registry.addResourceHandler("/static/**")
                .addResourceLocations("classpath:static/");
    }
?
    /**
     *  攔截器
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        List<String> list=new ArrayList<>();
        list.add("/static/**");
        list.add("/webjars/**");
        list.add("/swagger-ui.html");
        list.add("/**/swagger-resources/**");
        list.add("/csrf");
?
            registry.addInterceptor(myinterceptor)
                    .addPathPatterns("/**").excludePathPatterns(list);
    }
}
?

攔截器類：

@Component
public class Myinterceptor implements HandlerInterceptor {
?
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("進入攔截器");
        return false;
    }
?
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("123");
    }
?
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("456");
    }
}

Swagger2類：

@Configuration
@EnableSwagger2
public class Swagger2Config {
?
    @Bean
    public Docket createRestApi() {
        return new Docket(DocumentationType.SWAGGER_2)
                .apiInfo(apiInfo())
                .select()
                //為當前包路徑
                .apis(RequestHandlerSelectors.basePackage("com.djl.springboot"))
                .paths(PathSelectors.any())
                .build();
    }
    //構建 api文檔的詳細信息函數,注意這里的注解引用的是哪個
    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                //頁面標題
                .title("面試題查詢系統")
                //創建人
                .contact(new Contact("admin","www.rockguide.com","403783154@qq.com"))
                //版本號
                .version("1.0")
                //描述
                .description("面試題查詢")
                .build();
    }
}

9：異常處理

@Component
public class MyException implements HandlerExceptionResolver {
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
?
        HandlerMethod handler = (HandlerMethod)o;
        String s = handler.getBean().toString();  // 報錯的類名
        String method = handler.getMethod().getName(); //報錯的方法名
        System.out.println(s);
        System.out.println(method);
        return new ModelAndView("error.html");
    }
}

10：Cors跨域

    /**
     *  跨域配置
     * @param registry
     */
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("http://*")
        .allowedMethods("*") //請求方式
        .allowedHeaders("*") //請求頭
        .allowedOrigins("*"); // 請求域名
    }

11：JWT加密

?
public class JWT_Use {
    // 超時時常
    public static final long TIME_OUT = 1000*60*30;
    // 私密令牌
    public static final String SECRET_TOKEN = "djl";
?
    // 獲取Token的值
    public static String getToken(){
        String token = "";
        //過期時間
        Date date = new Date(System.currentTimeMillis() + TIME_OUT);
        //私鑰及加密算法
        Algorithm algorithm = Algorithm.HMAC256(SECRET_TOKEN);
        // 設置頭的信息
        Map<String,Object> header = new HashMap<>();
        header.put("typ", "JWT_Use");
        header.put("alg", "HS256");
?
        token = JWT.create().withClaim("Login_UserName","djl")
                            .withClaim("Login_PassWord","111666")
                            .withExpiresAt(date).sign(algorithm);
        return token;
    }
?
    public static void main(String[] args) {
        String token = JWT_Use.getToken();
        System.out.println(token);
    }
?
}