標籤: 台北網頁設計公司

一、自定義註解

先聊聊這個需求，我需要根據用戶的權限對數據進行一些處理，但是痛點在哪裡呢？用戶的權限是在請求的時候知道的，我怎麼把用戶的權限傳遞給處理規則呢？想了以下幾種方案：

1. Mybatis 攔截器：如果你的權限參數可以滲透到 Dao 層，那麼這是最好的處理方式，直接在 Dao 層數據返回的時候，根據權限做數據處理。
2. Dubbo 過濾器：如果 Dao 層沒辦法實現的話，只好考慮在 service 層做數據處理了。
3. ResponseBodyAdvice ：要是 service 層也沒辦法做到，只能在訪問層數據返回的時候，根據權限做數據處理。（以下介紹的正是這種方式）

那麼現在有個難點就是：我怎麼把 request 的權限參數傳遞到 response 中呢？當然可以在 Spring 攔截器中處理，但是我不想把這段代碼侵入到完整的鑒權邏輯中。突然想到，我能不能像 spring-data-redis 中 @Cacheable 一樣，利用註解和 SpEL 表達式動態的傳遞權限參數呢？然後在 ResponseBodyAdvice 讀取這個註解的權限參數，進而對數據進行處理。

首先，我們需要有個自定義註解，它有兩個參數：key 表示 SpEL 表達式；userType 表示權限參數。

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface ResponseSensitiveOverride {

    /**
     * SPEL 表達式
     *
     * @return
     */
    String key() default "";

    /**
     * 1：主賬號、2：子賬號
     */
    int userType() default 1;
}

然後，把這個註解放在路由地址上，key 寫入獲取權限參數的 SpEL 表達式：

    @ResponseSensitiveOverride(key = "#driverPageParam.getUserType()")
    @RequestMapping(value = "/queryPage", method = RequestMethod.POST)
    public ResponseData<PageVo<AdminDriverVo>> queryPage(@RequestBody AdminDriverPageParam driverPageParam) {
        return driverService.queryPageAdmin(driverPageParam);
    }

二、SpEl + AOP 註解賦值

現在 SpEL 表達式是有了，怎麼把 SpEL 表達式的結果賦值給註解的 userType 參數呢？這就需要用 、 和 的知識。

@Aspect
@Component
public class SensitiveAspect {

    private SpelExpressionParser spelParser = new SpelExpressionParser();

    /**
     * 返回通知
     */    
    @AfterReturning("@annotation(com.yungu.swift.base.model.annotation.ResponseSensitiveOverride) && @annotation(sensitiveOverride)")
    public void doAfter(JoinPoint joinPoint, ResponseSensitiveOverride sensitiveOverride) throws Exception {
        //獲取方法的參數名和參數值
        MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
        List<String> paramNameList = Arrays.asList(methodSignature.getParameterNames());
        List<Object> paramList = Arrays.asList(joinPoint.getArgs());

        //將方法的參數名和參數值一一對應的放入上下文中
        EvaluationContext ctx = new StandardEvaluationContext();
        for (int i = 0; i < paramNameList.size(); i++) {
            ctx.setVariable(paramNameList.get(i), paramList.get(i));
        }

        // 解析SpEL表達式獲取結果
        String value = spelParser.parseExpression(sensitiveOverride.key()).getValue(ctx).toString();
        //獲取 sensitiveOverride 這個代理實例所持有的 InvocationHandler
        InvocationHandler invocationHandler = Proxy.getInvocationHandler(sensitiveOverride);
        // 獲取 invocationHandler 的 memberValues 字段
        Field hField = invocationHandler.getClass().getDeclaredField("memberValues");
        // 因為這個字段是 private final 修飾，所以要打開權限
        hField.setAccessible(true);
        // 獲取 memberValues
        Map memberValues = (Map) hField.get(invocationHandler);
        // 修改 value 屬性值
        memberValues.put("userType", Integer.parseInt(value));

    }
}

通過這種方式，我們就實現了為註解動態賦值。

三、ResponseBodyAdvice 處理數據

現在要做的事情就是在 ResponseBody 數據返回前，對數據進行攔截，然後讀取註解上的權限參數，從而對數據進行處理，這裏使用的是 SpringMVC 的 ResponseBodyAdvice 來實現：

@Slf4j
@RestControllerAdvice
@Order(-1)
public class ResponseBodyAdvice implements org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice {

    private static final ThreadLocal<Integer> threadLocal = new ThreadLocal<Integer>() {
        @Override
        protected Integer initialValue() {
            return SysUserDto.USER_TYPE_PRIMARY;
        }
    };

    @Override
    public boolean supports(MethodParameter returnType, Class converterType) {
        if (returnType.hasMethodAnnotation(ResponseSensitiveOverride.class)) {
            ResponseSensitiveOverride sensitiveOverride = returnType.getMethodAnnotation(ResponseSensitiveOverride.class);
            threadLocal.set(sensitiveOverride.userType());
            return true;
        }
        return false;
    }

    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
        if (body != null && SysUserDto.USER_TYPE_SUB.equals(threadLocal.get())) {
            // 業務處理
        }
        return body;
    }
}

題外話，其實我最後還是擯棄了這個方案，選擇了 Dubbo 過濾器的處理方式，為什麼呢？因為在做數據導出的時候，這種方式沒辦法對二進制流進行處理呀！汗~ 但是該方案畢竟耗費了我一個下午的心血，還是在此記錄一下，可能有它更好的適用場景！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

※小三通物流營運型態?

※快速運回,大陸空運推薦?

摘錄自2018年9月21日蘋果日報美國洛杉磯報導

洛杉磯市議會周二（18日）通過議案，將立法禁止銷售皮草衣飾。議會全體投下贊成票，立場堅定；洛杉磯將成為美國禁售皮草的最大城市，可望為其他時尚重鎮帶來示範作用。

洛杉磯市議會以12比0的票數，一致贊成禁止商業皮草。立法機構負責草擬法規，由市議會審核，正式法規將在通過審議的兩年後生效。預計這類法規會為宗教目的、合法漁獵執照持有者另闢途徑，允許合法使用或生產動物皮草。

加州舊金山、西好萊塢、柏克萊都已限制皮草，但像洛杉磯這麼大規模的城市還是首例。提出此議案的議員科瑞茲（Paul Koretz）表示，洛杉磯是世界時尚之都，期許此舉能成為世界典範，紐約、芝加哥和邁阿密等大城可以跟進。

本站聲明:網站內容來源環境資訊中心https://e-info.org.tw/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

※小三通物流營運型態?

※快速運回,大陸空運推薦?

日前，中能工業智慧技術研究院發佈了EVOP電動汽車運營平臺，打造中國最強電動汽車網聯大腦。

從傳統意義上來說，電動汽車只是“行駛+充電”的物理組合，滿足人們最基本的代步需求;而EVOP在此基礎上，通過互聯網和智慧化平臺，將電動汽車和充電設備打造成為能源互聯網產業鏈的重要一環。

和其他智慧化汽車應用相比，EVOP平臺基於中國最強工業大腦DPEN而打造，將資料、資訊和互聯網相結合，讓電動汽車產業鏈變得更智慧。DPEN支持數千萬個採集節點。在DPEN的引領之下，源源不斷的資料進入EVOP平臺，分門別類進行存儲和分析，並通過互聯網傳遞到每一輛電動汽車或者充電設備上，指導設備智慧化、高效率運行，並實現充電網、互聯網、車聯網“三網融合”。

在充電端，EVOP可以輕鬆實現智慧充電功能，它可以即時檢測並調整充電狀態，加強電池的健康管理，引導智慧有序充電、計量計費，並讓車主通過手機隨時瞭解充電情況;而商業地產、物業管理公司、電動汽車廠商等運營商和服務商可以通過雲平臺實現充電樁和車載電池的智慧管理，提供良好的增值服務。

在行駛端，由EVOP平臺海量採集的資料經過精確梳理和分析，通過雲平臺提供給每一位車主，在EVOP營造的車聯網中智慧、高效、安全出行。人們不僅可以隨時瞭解車輛和電池的資訊，快速查詢身邊的充電設備、預約充電;也可以在EVOP的指導下獲得最佳行車路線和最佳能效使用方案;亦可以在EVOP的社交平臺中交流經驗、分享資訊、找到志同道合的朋友，享受 “大資料+互聯網”的時尚車生活。

本站聲明:網站內容來源於EnergyTrend https://www.energytrend.com.tw/ev/,如有侵權,請聯繫我們,我們將及時處理

【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

※小三通物流營運型態?

※快速運回,大陸空運推薦?

1. select的使用

　　定義：在golang裡頭select的功能與epoll(nginx)/poll/select的功能類似，都是堅挺IO操作，當IO操作發生的時候，觸發相應的動作。

1.1 一些使用規範

　　在Go的語言規範中，select中的case的執行順序是隨機的，當有多個case都可以運行，select會隨機公平地選出一個執行，其他的便不會執行：

 1 package main
 2 
 3 import "fmt"
 4 
 5 func main() {
 6     ch := make (chan int, 1)
 7 
 8     ch<-1
 9     select {
10     case <-ch:
11         fmt.Println("隨機一")
12     case <-ch:
13         fmt.Println("隨機二n")
14     }
15 }

　　輸出內容為隨機一二里面的任意一個。

　　case後面必須是channel操作，否則報錯；default子句總是可運行的，所以沒有default的select才會阻塞等待事件 ；沒有運行的case，那麼將會阻塞事件發生報錯(死鎖)。

1.2 select的應用場景

timeout 機制(超時判斷)

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func main() {
 9     timeout := make (chan bool, 1)
10     go func() {
11         time.Sleep(1*time.Second) // 休眠1s，如果超過1s還沒I操作則認為超時，通知select已經超時啦～
12         timeout <- true
13     }()
14     ch := make (chan int)
15     select {
16     case <- ch:
17     case <- timeout:
18         fmt.Println("超時啦!")
19     }
20 }

　　也可以這麼寫：

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func main() {
 9     ch := make (chan int)
10     select {
11     case <-ch:
12     case <-time.After(time.Second * 1): // 利用time來實現，After代表多少時間后執行輸出東西
13         fmt.Println("超時啦!")
14     }
15 }

　　判斷channel是否阻塞(或者說channel是否已經滿了)

 1 package main
 2 
 3 import (
 4     "fmt"
 5 )
 6 
 7 func main() {
 8     ch := make (chan int, 1)  // 注意這裏給的容量是1
 9     ch <- 1
10     select {
11     case ch <- 2:
12     default:
13         fmt.Println("通道channel已經滿啦，塞不下東西了!")
14     }
15 }

　　退出機制

 1 package main
 2 
 3 import (
 4     "fmt"
 5     "time"
 6 )
 7 
 8 func main() {
 9     i := 0
10     ch := make(chan string, 0)
11     defer func() {
12         close(ch)
13     }()
14 
15     go func() {
16         DONE: 
17         for {
18             time.Sleep(1*time.Second)
19             fmt.Println(time.Now().Unix())
20             i++
21 
22             select {
23             case m := <-ch:
24                 println(m)
25                 break DONE // 跳出 select 和 for 循環
26             default:
27             }
28         }
29     }()
30 
31     time.Sleep(time.Second * 4)
32     ch<-"stop"
33 }

2. select的實現

　　select-case中的chan操作編譯成了if-else。如：

1  select {
2  case v = <-c:
3          ...foo
4  default:
5          ...bar
6  }

　　會被編譯為：

1  if selectnbrecv(&v, c) {
2          ...foo
3  } else {
4          ...bar
5  }

　　類似地

1  select {
2  case v, ok = <-c:
3      ... foo
4  default:
5      ... bar
6  }

　　會被編譯為:

1  if c != nil && selectnbrecv2(&v, &ok, c) {
2      ... foo
3  } else {
4      ... bar
5  }

　　selectnbrecv函數只是簡單地調用runtime.chanrecv函數，不過是設置了一個參數，告訴當runtime.chanrecv函數，當不能完成操作時不要阻塞，而是返回失敗。也就是說，所有的select操作其實都僅僅是被換成了if-else判斷，底層調用的不阻塞的通道操作函數。

　　在Go的語言規範中，select中的case的執行順序是隨機的，那麼，如何實現隨機呢？

　　select和case關鍵字使用了下面的結構體：

1 struct    Scase
2   {
3       SudoG    sg;            // must be first member (cast to Scase)
4       Hchan*    chan;        // chan
5       byte*    pc;            // return pc
6       uint16    kind;
7       uint16    so;            // vararg of selected bool
8       bool*    receivedp;    // pointer to received bool (recv2)
9   };

1  struct    Select
2      {
3      uint16    tcase;            // 總的scase[]數量
4      uint16    ncase;            // 當前填充了的scase[]數量
5      uint16*    pollorder;        // case的poll次序
6      Hchan**    lockorder;        // channel的鎖住的次序
7      Scase    scase[1];        // 每個case會在結構體里有一個Scase，順序是按出現的次序
8  };

　　每個select都對應一個Select結構體。在Select數據結構中有個Scase數組，記錄下了每一個case，而Scase中包含了Hchan。然後pollorder數組將元素隨機排列，這樣就可以將Scase亂序了。

 3. select死鎖

　　select不注意也會發生死鎖，分兩種情況：

　　如果沒有數據需要發送，select中又存在接收通道數據的語句，那麼將發送死鎖

1 package main
2 func main() {  
3     ch := make(chan string)
4     select {
5     case <-ch:
6     }
7 }

　　預防的話加default。

　　空select，也會引起死鎖。

1 package main
2 
3 func main() {  
4     select {}
5 }

 4. select和switch的區別

select

select只能應用於channel的操作，既可以用於channel的數據接收，也可以用於channel的數據發送。如果select的多個分支都滿足條件，則會隨機的選取其中一個滿足條件的分支， 如規範中所述：

If multiple cases can proceed, a uniform pseudo-random choice is made to decide which single communication will execute.

｀case｀語句的表達式可以為一個變量或者兩個變量賦值。有default語句。

31 package main                                                                                                                                              32 import "time"
33 import "fmt"                                                                                                                                              
35 func main() {                                                                                                                                             36     c1 := make(chan string)
37     c2 := make(chan string)                                                                                                                               38     go func() {
39         time.Sleep(time.Second * 1)                                                                                                                       40         c1 <- "one"
41     }()                                                                                                                                                   42     go func() {
43         time.Sleep(time.Second * 2)                                                                                                                       44         c2 <- "two"
45     }()                                                                                                                                                   46     for i := 0; i < 2; i++ {
47         select {                                                                                                                                          48             case msg1 := <-c1:
49             fmt.Println("received", msg1)          
50             case msg2 := <-c2:
51             fmt.Println("received", msg2)  
52         }
53  }

switch

　　switch可以為各種類型進行分支操作， 設置可以為接口類型進行分支判斷(通過i.(type))。switch 分支是順序執行的，這和select不同。

 1 package main                  
 2 import "fmt"
 3 import "time"  
 4 
 5 func main() {                                                                                                                             
 6      i := 2
 7      fmt.Print("Write ", i, " as ")  
 8      switch i {
 9          case 1:
10          fmt.Println("one")
11          case 2:                                                                                                                                  
12          fmt.Println("two")
13          case 3:                                                                                                                      
14          fmt.Println("three")
15      }                                                                                                                                             
16      switch time.Now().Weekday() {
17          case time.Saturday, time.Sunday:
18          fmt.Println("It's the weekend")
19          default:                                                                                                                                      
20          fmt.Println("It's a weekday")
21      }                                                                                                                                                 
22      t := time.Now()
23      switch {                                                                                                                                         
24          case t.Hour() < 12:
25          fmt.Println("It's before noon")                                                                                                              
26          default:
27          fmt.Println("It's after noon")                                                                                                                  
28      }
29      whatAmI := func(i interface{}) {                                                                                                                   
30          switch t := i.(type) {
31              case bool:                                                                                                                              
32              fmt.Println("I'm a bool")
33              case int:                                                                                                                                 
34              fmt.Println("I'm an int")
35              default:                                                                                                                                 
36              fmt.Printf("Don't know type %T\n", t)
37          }
38      }
39      whatAmI(true)                                                                                                                                     
40      whatAmI(1)
41      whatAmI("hey")                                                                                                                                 
42  }

 

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理
【其他文章推薦】

※想知道網站建置、網站改版該如何進行嗎?將由專業工程師為您規劃客製化網頁設計及後台網頁設計

※不管是台北網頁設計公司、台中網頁設計公司，全省皆有專員為您服務

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

※帶您來看台北網站建置，台北網頁設計，各種案例分享

※小三通物流營運型態?

※快速運回,大陸空運推薦?