p9%ClHI6(bf{deB6i~gcQSnINJ`0r!w$Mghs~iV59=0W)QCIO;AbpM3C7f;Y
z#3~sAx7N+7vDv8X8TD=14FVnOR#7kS=sYm)J)>eDm`4J0>(^v>r!EqU`E^r(U_-g0
zEwWwNc?ZEeBQP#AU3aw@ynF9`H&o!Bf6@H*xN_qJ1i5zms6Y!dYS`L4luBG)7q3MM-A1MR&ve$C&X#s(RN6={`fw2$sb5Ja#%cmD;K!Lk{-9Ed(clt%7
z9}g@fwQa9ZTYcZyKCZDukyG)K?Y3{&u7R&!P9SPq?)_rYD^2X(IyQRVYSfFybKX%N
zNNi@NPjPGJ6rEXxV{cM9*_87ev}ct}QaQz7=A7t}
zLdRGW6X#G6#UMuc=#3$TY0kh9Z}Jdr51l#e)HQ(^zw{E_$5%Ot9wG-ZKwLkOy+jUR
zo)%g61J=fu8=vC^>x?3U9KImGc|Pi2Vx22i?y-`q4Q!Iv7OhKAE*Oq~lO+`)m9Mr?
z(SN~N@l7;1R`r5T#7Lwx3~~DvzUH_>h3+zQ8zZisAzhemVtVrovxQ6(_p^$W;gf76
zbBcvzuSP-@`l;4s(>VE71t4g4M?;
zWhcgon;>qSs8OOOuz*QNo@Ex+iJSNadCDK7Jlpt|F%~>|!m?~%o>lDNB}qx!cPNmn
z6zZ`QYS>fd71^gfrJ{&9k~p@ORM88%xuU*e*ST8l;(J#s%y5
literal 0
HcmV?d00001
diff --git a/version5/krpc-common/target/classes/common/serializer/myserializer/JsonSerializer.class b/version5/krpc-common/target/classes/common/serializer/myserializer/JsonSerializer.class
new file mode 100644
index 0000000000000000000000000000000000000000..a9726a38c614041f8cbb1d0707f5191a54544c8c
GIT binary patch
literal 2794
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
literal 0
HcmV?d00001
diff --git a/version5/krpc-common/target/classes/common/serializer/myserializer/ProtostuffSerializer.class b/version5/krpc-common/target/classes/common/serializer/myserializer/ProtostuffSerializer.class
new file mode 100644
index 0000000000000000000000000000000000000000..8cf83ad47d3f35ab97aa123e6f2aa99c8aa5e968
GIT binary patch
literal 3186
zcmai0TUQfT7~LlqCWI&&6&n=^3KfVLFSROIte_|gc)?38y*MO?Fff@(CleKWzyF1<
zKK0F)KG+v@>8if9YxU3c54dXgnHiD^vUIV?IdkT_>~DXUGynYe)Hl|WKp*O+cuwwtX=$IwmVzRX%R)6CkQ;UqMql-CUc+xjLOCTCp7uu8-IHx#t?
z6gFYAK%ykwF;lNr1-A6{hors3;Uu5%Lq=dn^Q%e2T9U<4`jSo(Z((N&yUa>xiH_RtsX>cBW*ts+Z)o
zlb=fshXmT!oF;J)M^bnPM}2c=WWm%OSsb&is_WDWu1!Bj`et9T7Pjxmd6R9D4=FL1
z$8cQ3i4=w~EYR8TyN)zdY00}2bg5ef;@{WgFvw-tV{oM5J@!JwbiMU7oMHzAq{`KX
z%-6}Q3np+{Ab+NwFvO=1KoRjg-HIE!(1QCT`A
zIqukHfx*7n(GXj&Ekrd-&I_aoG{2;m^?b!%wDZ@Q_%tWeg%mDgQeb;oUy|gOO?1<6
z7d)1A%jFo@)|}^HY9uf%kZhEUhRXu|Z>X?3HOzNx%q}tu?JRLQT`SK?=bAoe@+3XU
zPBw4o9A$hC4rA_uK`cin-{7GEsNsv1(aLE3$;b*^r-j*&Y(v#KbP`byQG0GtVQJ(&
zAenQz8qBqhHQgEvE=tUK6N-a*jYLyF3v8Hi^}^DWUh$&TFvqTH9ss^c4aKGsytd%j
zcNIGtZn3OGvw(?YX*4xv9k(F4+d=`=>yrevmBXzqCcL4f-@h-gIi%tDI4NvS5ywH0
zrmbs*PY#UGy2cse4-H;zwB0&mlq}t?IYhL*xx73VzE;Au{bEzICft}o39|lX?3z=M
z<7^~>%zC*$pz_DtcGR|A&KkWkCEW$PSZ!~?{Ukoe7aG1)9q^SvPb1Zab;n+kdEbxU
z6yv%YQ@jCw371bG=o>w+TSZe=dnRprsa6>dQ4s(Roir&bYSs}C&%+>zVHN@tW4!ui
z3|9^(@D16#ZY^2%T`L>pGwag!P*w<}CM-)j9=)=v;d_DJR{~xy4h=u@W_rCSE8Y(p
z-Mn%l5V*wA(!!PBI{dxDr#x4|H9qhN;ty^jxEcrnn=!+E$``;jT<4R(4cz3fQvMfF
z8UluLe`CW_Xt&a>kI?o!w}Oq2k)GNd!DH;0&g~z3jNL=A!4>q}e1Hu@ac`H2KhMM-
z(qAWfF-R+e1f$ldhhP9n?mG~}c5K8B?mGF`P1(H|Ko2GN^6Kj0RnzOC93hfkB=7-l
zQHPiUylVF$W{J3i(jVbt&toS(!Kd_ejQ_sIZR&I(y747;Bc>szA)-Oo_&p#r6kecJ
zgQSspl>FcYh4~4`QJwn>iQKba0|xpO0|UEOFfh%q(+oTMCl0RQFqg;*-W`fRK>JY3
zQ;gh7zyAoM&vTi0CiWO(nfOCm?oyXBPBH|Q2A_lhv@(BNNKXcbDRGQ4LzFs>qd0+6
z{ER)vTS=wrDhW79Tq@u=-zKpD!%NYHIvp3hfK|>fU=d5CBZEUQQKnuO{V0lJwAvO}
zu_&oZz?ZTqb(<&Mh_$x9q(a=|N|L05$bQs~Rzs9$G
NN^#f%mc@k@<+9?X7cZh+Km!881}i_pLK>svPTkX!&k;J?UkHX
z{Ab~1>VD5J*-&-;&97?^GTT6L5sM`bBFmqKqlhdliQfFLkDK#>*<
z53%9SCCIcB#U>unZ}6DbzaSt)bN>SD;}?V*#qd{%7f6tiJjYxZABuvDqzJj`BQq|t
zOvs9lL|i08$eNFcE|Mi=-AB@doa1%~Kal%OoMCLyxCW8NG<`xVG-gQaDyoF;A&VB)
j@q~6$o<=;yGqPrJg6G(#3|^2W(d;2FX~j?`EQHD*^SWh_
literal 0
HcmV?d00001
diff --git a/version5/krpc-common/target/classes/common/spi/SpiLoader.class b/version5/krpc-common/target/classes/common/spi/SpiLoader.class
new file mode 100644
index 0000000000000000000000000000000000000000..f8829d46f18ea29ea6471440faa28517c171a97d
GIT binary patch
literal 5133
zcmbtYd3+RC9sf>tH?!Fc*Agg8p-o!~BplmTpmY@Bx6uero;%xy9M-)84)_Q9_DqeVNtNy3`K=J$D%x)%RLH(HIGxO%X-}_zP
z-|zQ+FVDPu`~-kS_$9)i4fm(xjbi
z*0Ga?oSE#(nH`RvG4cvDOAIocS*_I(89B+sbRB<$qL2|ZCs%j`p7zl1VV9oW~zp(aJ7Ofvif$T#j(@6
zyTNq(I4Zch?b6WcLB76q6%3By8eFU5It|lsy@DBOJK0xs9mh(hoxG7Won+o9IK_P0
zNUrq<>u4u^Ku4BlC~n%N#YxLM%z{hD%)m?)4H_CTOTp+N`^2(>sOcJc-F4{Vi6wO8
z?sk8k9OhuIill}caHE3w5Qh>8A@0))oyJb`V?=BgJ6@q-9_A|u+j4q1^1jbi+)Se+
zKihDV>(+LtxP^Mi8M0?9Bddo2^z#)Vwi6`%FX@-=$#-?xr$5PTot{
z>nrUJY?c{LPe!p-LmC+xYZjIk3TCgZZ?%lJypt7KKVpZ7kvjBf=mm`m5lRIMgJgb$
z1U8oPbmWx4Xq$%ZqF6=JmQyfPQ0#aaDza{M_vM`(LZKKeI2v+zHEV>P$#fNSIVM}d
zpys6*7`}rTt6;Ku+(dk=Y2BGNa<1vvDvAo~hr~#4bUJREQ?xT>DpB8dXxIr>o{;7A
zGKD&vd~dQ~^~~Fr>~MN}jeJua3SJ`$%xe`~>pQ~FiKYrAq!#z$bt+!3;SIQtPQRER
z9bx42BB>jLUiGmKxUlRQ+9@D;qlWwOCMwEOb5TLNGyp0dR4{qS4{M9IYi5nI2jV%s@TjONwYIUN-CtDk
z?qMi+^RB52h{`&sc<*p3%QAX(YiT-7_{&srggs672~F>d;r;l4iVte|5FTeGx!BEZ
zdYYA!xYp2J9+C=%<&2jg4I=?p@nQN``b?Hv9#H9GK5y7=Qk*T`uzUnPfe?jsiL`Qy
zd7h;Adl<^CJfxZfkPZX+KN84jms&Q@>L?w(M&8sdbGMOCW_J~aKDx@orp5AC!TkSH
zk3jptojixSZg1bxvZk}GefgH#+FA4BBQ0P6ln&SRx>Yoy_#}(T>elY1bJ{!Gk^#k7
zP+Ob~-7-d$-_BxotC8;(`7U!Uty}ALTEuUEGVJ!5%;||`gM+;WwNpj2!B(Sk?P5(1
zZ5Mq+Ox-$@dWZ32RhgzDb*0x2>PqvOdIVs5B45CO*YIgf9%;%ORJ>5vc;+?F{9RF
zJ#I3ZWLqJe=L8+QD_3%ET|ha>t+`PkzBRz&auNG~1SAtYAVlct=S9g2LXS~huAbgb
z4P-2+_-3iLOTlGtioT(eAq_;omf2paJ_>FgLDv-6SURHvQ+^>;5Zt)d=&{&aoBhU`
zoM^~`wM%GS4lfU?i2;6|le@cRVl5f5@V}+CiXWEhl61)B^it5$+?@&t^etN)G%TQ9
zfU@KkYR#~1PBZ@Hg(B7^8{allkQ{Jecqm&QPC4i*8w6?8Td+_%#!}VwH>Htb(iBbUG(f?>hCOO4YNF)|WChRj)+x
zJ60_*X*;f@AT9ejvGNBVPMwb2A;QVX^0bkWMgn#$l8hxlkp4-*tRX?(IV_G;qrz@V
zWgFja+eTi3Z4^}em7+!fQOUn5UZhQzCuL#uz`!-^4yt$;3uCfqs5qJ|ZjEf7KEiPo
zp5!-Mhw}GF`F#K%lnsYVK2f52a(ux1Xr#WE5|VfIEwntIma+v
zK`NXGAH!^gbc14alY%c{K`Jtcg_{PE+LVY4p!o=HJ%W~0b)tFzZJSc+DQrxr185&W
z=e`RsB-HpT2hg?e!dZ?s3}90#nuwl=JdPU@(a=pKOVuQzVL6B;Vn^|+RBdCTb^!Wb
zjGmpSNz@*L5yFN87xoMO<^d#9sz1`mN=-xuU?JeF*)D$Z_nZKdO)6o)8XP
zSSoCt?J+q>k8Z|se1)C$*YGr+<+~L>!Sl%bZEtHhP9yH-0G_%=T#1?EZ_G1ZMekIee8K2;u9}%CIl%6lHlkPx0;1
zpDxpXgY-{xelxUlh^tunGN!1gQ!zuuobzZ@u|UPbbGVaBFQIC=3hM$5imKvoWtq|=
z<02G3qW?nGG8NCfggE#3nei;QeGA|ALRWd1n5dNdpa{^_gp+9QsiJvxopVlO+#nv<
zH2XN-47%u{lXDo?axp4m*I%A>9B=iO6Jhd5MGoPSL_{XQJ~YS=vG5K*)I=l+t|F8k
z6QOhjdr$gX$onbkwSkwxZFraeevcnDDP}x47a>Y<`e`Dsx6^PJ{}-`^adS80A;Vj*
zA$N)W+t5chn79X783`+BrzO$+4$-8=K89i>qC-@JJrd0-^6!^uhRA)RjFT{VFUEIC
z7m>Ku6EBa)_xSecPjk+r|2}mVXwF6WJf?X7ox@cG>jI{ux&)esn*dP2^@F&N(2p34
z&&kpwD$^o*MEp#Rk3Nd`9Y+5ko?uDYe;A|6qen!=Qe<+CmWoXxiz!s=YJUBgYgJ5=
lpYmN#^?ydnU&-fhrH2
literal 0
HcmV?d00001
diff --git a/version5/krpc-common/target/classes/common/util/ConfigUtil.class b/version5/krpc-common/target/classes/common/util/ConfigUtil.class
new file mode 100644
index 0000000000000000000000000000000000000000..7fb59017dc3665e25b24aa0326bc52ab7a038efb
GIT binary patch
literal 2372
zcmbtV-A@!(6#rdVoMjzAmJda-0%Bp8kD=C9Ws$aQ)zYr`!H0!@=rCNC!P%L0b`~^-
zhdwkmO?@>neKAd&rb%P8Z2+OP@BKRz=u`gz)AZb(k-Zh#J~W$|z4y%d_?_Q5_uSw9
zT=@mSDa=Puf>H$`6=m4PuxD1E(=|)C)7tsTS#Ed?yZTJq^!gb}+hb#4gc%T_-);q}
ziV9RR)EiDFGc7IY*wbcul$Hz;%h9KN0mEQ>s^~mv>A74&5)6B;X{UFP#3Usj
zQbNHVhP_2+zU@HXw5GTlMwDTQvE%ZU)87oz7&vn}w=RlvBNXRJ?+tw6~lz
zLp0^MX)R|>ADh)uPCCt9LV1iK{`;qQHr5`j-@W~0b+M`K)
z`bnSk_zKF16-$A$K_c6)TAY*{UW%CF>$Ca
zQ_cT9`pAsy%hgX75oTs}4BjCSUqR$6G
zZIgBRw0T2BC{h^kPh&CV$YF10pNFoOv%hPieFwtem?ocTTKm4k^lgTACOsvXEySqw
zW3Uqhco)eRR#7z`tzJUSQ0Fr0@1e3Q+PH|9I_bIG6>SlJt7skXTExpsi1&sXLW}6Q
zhuR;YMPC)t$9Sz2-=bOw629P6DH=lYjzzrru(wRe&%_t;PD9yaoC{$U7ssQ+4P{Fh
z{gvQerj)PXZGs~RI!e%ieZ=m5RO0{|aS(^;66`?>PS9!)N5~>hx*bGZC$7`AbCoRm
zDH)x#ufd`!P+D8GECjR&S%wHIA>TRJaEQ_#oI{p;ge200r6A3vrv{;CXjD-344n#E
pE6yqe)MqnCe0y8vZZ6c4su+zd
+
+ 4.0.0
+
+ com.kama
+ version5
+ 1.0-SNAPSHOT
+
+
+ krpc-consumer
+
+
+ 17
+ 17
+ UTF-8
+
+
+
+ org.springframework.boot
+ spring-boot-starter-web
+ RELEASE
+ compile
+
+
+ com.kama
+ krpc-api
+ 1.0-SNAPSHOT
+ compile
+
+
+ com.kama
+ krpc-common
+ 1.0-SNAPSHOT
+
+
+ com.kama
+ krpc-core
+ 1.0-SNAPSHOT
+
+
+ cn.hutool
+ hutool-all
+ 5.8.10
+
+
+
+
\ No newline at end of file
diff --git a/version5/krpc-consumer/src/main/java/com/kama/consumer/ConsumerTest.java b/version5/krpc-consumer/src/main/java/com/kama/consumer/ConsumerTest.java
new file mode 100644
index 0000000..c04606a
--- /dev/null
+++ b/version5/krpc-consumer/src/main/java/com/kama/consumer/ConsumerTest.java
@@ -0,0 +1,66 @@
+package com.kama.consumer;
+
+import com.kama.client.proxy.ClientProxy;
+import com.kama.pojo.User;
+
+import com.kama.service.UserService;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * @ClassName ConsumerExample
+ * @Description 客户端测试
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 16:20
+ * @Version v5.0
+ */
+@Slf4j
+public class ConsumerTest {
+
+ private static final int THREAD_POOL_SIZE = 20;
+ private static final ExecutorService executorService = Executors.newFixedThreadPool(THREAD_POOL_SIZE);
+
+ public static void main(String[] args) throws InterruptedException {
+ ClientProxy clientProxy = new ClientProxy();
+ UserService proxy = clientProxy.getProxy(UserService.class);
+ for (int i = 0; i < 120; i++) {
+ final Integer i1 = i;
+ if (i % 30 == 0) {
+ // Simulate delay for every 30 requests
+ Thread.sleep(10000);
+ }
+
+ // Submit tasks to executor service (thread pool)
+ executorService.submit(() -> {
+ try {
+ User user = proxy.getUserByUserId(i1);
+ if (user != null) {
+ log.info("从服务端得到的user={}", user);
+ } else {
+ log.warn("获取的 user 为 null, userId={}", i1);
+ }
+
+ Integer id = proxy.insertUserId(User.builder()
+ .id(i1)
+ .userName("User" + i1)
+ .gender(true)
+ .build());
+
+ if (id != null) {
+ log.info("向服务端插入user的id={}", id);
+ } else {
+ log.warn("插入失败，返回的id为null, userId={}", i1);
+ }
+ } catch (Exception e) {
+ log.error("调用服务时发生异常，userId={}", i1, e);
+ }
+ });
+ }
+
+ // Gracefully shutdown the executor service
+ executorService.shutdown();
+ }
+
+}
diff --git a/version5/krpc-consumer/src/main/java/com/kama/consumer/ConsumerTestConfig.java b/version5/krpc-consumer/src/main/java/com/kama/consumer/ConsumerTestConfig.java
new file mode 100644
index 0000000..b816281
--- /dev/null
+++ b/version5/krpc-consumer/src/main/java/com/kama/consumer/ConsumerTestConfig.java
@@ -0,0 +1,20 @@
+package com.kama.consumer;
+
+
+import com.kama.config.KRpcConfig;
+import common.util.ConfigUtil;
+
+/**
+ * @ClassName ConsumerTestConfig
+ * @Description 测试配置顶
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 11:29
+ * @Version v1.0
+ */
+public class ConsumerTestConfig {
+ public static void main(String[] args) {
+ KRpcConfig rpc = ConfigUtil.loadConfig(KRpcConfig.class, "rpc");
+ System.out.println(rpc);
+ }
+
+}
diff --git a/version5/krpc-consumer/src/main/resources/application.properties b/version5/krpc-consumer/src/main/resources/application.properties
new file mode 100644
index 0000000..e784008
--- /dev/null
+++ b/version5/krpc-consumer/src/main/resources/application.properties
@@ -0,0 +1,7 @@
+rpc.name=krpc
+rpc.version=1.0.0
+rpc.port=9999
+rpc.serializer=Hessian
+rpc.host=localhost
+rpc.registry=zookeeper
+rpc.loadBalance=ConsistencyHash
\ No newline at end of file
diff --git a/version5/krpc-consumer/target/classes/application.properties b/version5/krpc-consumer/target/classes/application.properties
new file mode 100644
index 0000000..e784008
--- /dev/null
+++ b/version5/krpc-consumer/target/classes/application.properties
@@ -0,0 +1,7 @@
+rpc.name=krpc
+rpc.version=1.0.0
+rpc.port=9999
+rpc.serializer=Hessian
+rpc.host=localhost
+rpc.registry=zookeeper
+rpc.loadBalance=ConsistencyHash
\ No newline at end of file
diff --git a/version5/krpc-consumer/target/classes/com/kama/consumer/ConsumerTest.class b/version5/krpc-consumer/target/classes/com/kama/consumer/ConsumerTest.class
new file mode 100644
index 0000000000000000000000000000000000000000..03a4c00146356bb53eb0e9797fa1d705f3071b52
GIT binary patch
literal 3941
zcmcInU3e7b6@DkX$!s=*BufB669WeG&w>UkEKp5IAap}g5<-Qxbh10yOtL$Z&d!FU
z*8V8A)+&giShQNL6kFTMj}1wn*sEUj>0R%8GoSR{xlgk-EzP>t0Rs)`~#hOH$uOM*P9
zCNo;!h=etbJ>DbS9g$Lkz`usdAl6~Mj0Y4vh?)g3431iw8kbO-PHNhO1b^fHrlE2?
zggO};6l}!95^4)h#!MrfNoiKN(;WCucGH;)??2;xx%kD;9~kpqGr
z9n<33L)4qRYKs085STE>Ooves5t7Fhd<9Pssic{Z5Q>^sBAiZ+w2y_OW`c}}1h9jY
z{QTOCM8l0;a11PP!UBc_A~
zuVn+ar5gz^_AW`Ah63o2u<`cEtJza;Qca!EQ}_Aoe4UX=CR?3pPux|!M?sg+>OZbp
zMi6_kPezY|{rDQaS?V(hKAh2$aY6NsjZH;f6i}&m(9G>&!t~;Rj6MbZ__~+0%WjuY
zqB8*7yl&nt01H%wAYnkkAPz}bn^MO$rbA4%59{`*NDNyw?DQfCi)R-T*@aaYeptab
z@HBZN@H?QUGzslq)7-810K!pxQ^vPM)%f;;s?lMZNlj&jt!X^s%@}vxf$uvCR17l>
z5}M(_z5t&5&U-MT7jXp|SeZ(l5DKl!i7`!s7*(KSOoE~tbl%AjH#e4YVnL!wh
zTvd!#*HlcKuyxZ2fP`$geewBQXFkelym@ved+PM9Gw)@uKbM`I<;g;If%mq83?_+%
zW?3d>w=WY}PhE3!Yw1eUP!Lm?mhn9W&*1yy-s1G_R%5Kf(-O*AYH~&4OYWP+l8pZk
z@Ix6tQt)FuM>y|VFv;$ap&jqmr?hzP2I(igL_N#jLyK$V;>yq3Gq~?y*He3r_4oBf
zj}7!3>5?GzNLZ22pdoR&`FKH8vto3bai+w|sBUNnGO1zB8WdIDDS|OIIiy;;n7fO9
zdsL@|b;XLoD`@Gx72&xlRd-V2s0ZzQt__JAv6UR~yvtLLw(1mDtppXVT1HwzMXq~r
zFa3u-#(YUvL3>J_R)gplcaunq`wDJcF<`5)@m_VpbvamIXIjR&eE6J3N0@9`nF(8q
z7dG*Lq?#IztMvka`YleiDP-GnDwn~ai2(Tp(Ir$D?JZPWS}8F?t38qh{d^bLNqlmh
zS8%}0STU_z7ZI%z@fSUYXe~Ai7LqC~J$Bl*)QMir9yR0Xm1X!%5Et-~jNdBw9X{p_
zQOs1`m^8<=aMbaT66#1kEh{E?+QcKrIO>;am;l21=a(J9tAUHTZ
zp?SC8`^%ilyUTj(wtI4?noJJpwic;G8BzITkbS}@3f{&$oLvgyGOoz@RNPg6%6CBy
zD_rrMJA|CqSD|>k_5a7kh0&Wh`IcfSv;`jnxXK(kBq+!0qQ@{a%jusrCSiqG?#T55
zGOn@gEg{5mv6b=X1=+G7U@i@KA?ApH4MewuCCP{Nq7~z4J)Xx2wgWG4T!No)&X$>D
zKiBxl!RJpo3-edvZ)x*YNSBw))Mr#{uNc1u`RT{bq*09lm9+3dx~#6eQ2IV
zcgqZ-E%P`C%wWhriz72QHiOt45+yj$=1PyZd8Jc1=?kdr6^DJdg=eSz1V_Xrh7p)9
zNZtGz1HV%OghfFkL2AY(!qbe+?CrxO!xnySZY4x*=;q3Pw6mdmoM-IdDNi7Q?MM?0
z5orNn07vmlyh~uZ33orC^l^`Z_wXyO(Q5}b4mc7(OAdf*QFcds$L$T?!J`g(!44Uw
z!sFgAaIMWT9;gaEG>hX`u&uIs7SCQmtq8f~gj{?T1FI;umU=(nxCFn(hx`q3be?O!
a#~=8Ak^5&b>#p~*W1k~4=W!i3ufgc5Pg%Rb>o;cb!ZBue3ep?R>DUP1}>4fU{OR$EIe?_usic+=IxvD{QCX<2Y_cdw9!D*Ld(GlRtddx@j-ZzNao(r>|BO9
zVfCp>RQ{aM9FC?I)(G37j=lFH7G9{6cWUmve6tA0rMU*16VpX#!@)HRT?gyv5e8fm
z>%=Q^6?s+aTQ&)Hq{V3k5S|Q!tM|u|$TGhMO!8DEbAMEWDvf>{F8UU(JJ`fvsfo$Q
zESE7$(gnA&S(Pg7y=JPM38jdA8#i#%!nT83*dg>w3ClSIYhfy)gh}cmF9evu+#&4M
z2a^@COiiz)aV)d^vdz|5pGv}dpc472h-WfA7PE*EH_)MorXp3wzW`hLnaT+J!T*r^
zgjOsR%Nz_(YJ<9*-IU`ZoiktmA7R4I(ksjVmbvYTF49oGP)6<6-@QFHv%`Jd=B+Yc
z17!A!&%5k-d=uX*2VX&-%J4ltO&I8M8F*>R1nlAgdu{CDAtR>vh{+6T-?iNKH*|i&
r3O-}w@C&xCsJdu!N)H`u@JhHP<)A9VJ|1zb171-KnUpYMzk!24NaDNa
literal 0
HcmV?d00001
diff --git a/version5/krpc-consumer/target/krpc-consumer-1.0-SNAPSHOT.jar b/version5/krpc-consumer/target/krpc-consumer-1.0-SNAPSHOT.jar
new file mode 100644
index 0000000000000000000000000000000000000000..a2d7d283404a8cdefc8fe76221d6ec2b3b83ea01
GIT binary patch
literal 3110
zcmb7G2|Scr8y{mCF-eRu)=Nc<*_shIu1ZCi8K$u%bu*2zWH8@wiRO}BO=Yd5uCiwh
zxw;A^HxXm#wn7{q>#qci!dqKF|OB&w0-IKM#c{DJ2IIHd=U`
z+n1NQ+cMxuwsNvW+uB=WDRXABAP>Ndr;$3r1b#;W9k$qvY-w+6ZRO~MAzM$9+uKM)
zG^T4g5smC<=U<}Y?h>93vQc&&Ehr*-i!5Xy&m|phbbZZ%+Ou4$GLh;S{2Q_irYWzK
zMxd&2l-sD2u%qwV-$KJ`&)N}!?5{424Gn1Ko)}?
z?8^u;LfYJKBes)&=V6dGLxW(Ya7K~U&C?&kYT^NgGK$&JpK_Gki8_Z^Tt_ZmIS5}u
zQjJ!M0q)fX<`^1^r63aA?9Q
z{u+NLozigoeM0g>J4jU}Ecv{Wqm+^r!-E~YEdI}OO^Cpqq$3jn+9XFiW8;}P#wxrT
z`o8x`>)yT}&Vi0syrF~BwAKAd*|rs9o6q?qQ&Xf=yCk{mEhm%Z%afMrUp=^b1v>i8
zPOrw*JRe;0DlERhzPUgBmQ#=+N02ez89;{zNm&%7>il4YNj0}3Orh@46>W=RvWYHc
z$D)x(k6n4z2a8D`3Y#fNRomb5pill)2Hnv3U{^?mc^2%5wPA@3G~(GtOS(>=S|g`L
z+8kSzSY+f*>|Dkm{k78haWkVTdo;|xLV5afErVxZs!>EUs?8i-yui
zgcq6Lh54gty__arZ#e77$(o=}6F=LBkkdn-YYewqUW=8G4uc_(n^JZdFw0^#E6Q{@eV9Fy
z_Ne$e-Q9ks?997^Q-mOvH1bp)?S1~%nN84w8l-54x@&;frY&#^I}2M4VmHiGt{H}o7)
ziOR`IfN3R{-@F5_N8-=;RO(r#_P-u2Y(1_82~e*-^+A6kg_Fe5cfGnQsm7y}!d6e(
zp}t+G_IB)Ua)05iGXwaBoYgtUJ}!T3rHy`L{IhxCT7)W7UTGaqpq`93`oxM%xR!l4
zRL$ydY&t2#rJCXFoc+?zK#*EM|HL-kD^QRo##SG0`}k8DBHW;3`(%C!;f$(
zy5C7RLK+pi^NOx*s}h8LuK1%qa?OFB+(Yj*t#9#6ttVrReA~dJ$SqC12Fo|fO?i0L
z>+$z;HKA3-#+ok#=8a9KO^vh&My#zT$OR=#Xxz#CmP-ZWrR%hpH%#IkXj3IWDs97e
z>JUbsH8h)iDwLn<7=98}YSQqogeL8Do7qV*-tYgFM4n+?x5@R
z`ZN4;)l0dOmvL?NKR!aGJpI`1dt+-(uWR^?3o#MdvpYbi!wk
zS^fm!#r^BCgCEp5*iJq5Lhp4JiLuu_?@s%@U9>5L*&b<()d>YQLkQ4~|F2CU%6^U^
z4m={-4rNQ;VN>ihMn(~N{ex76Rs(02E!hQ!bH*9}j<2r9<0vczg&jCN4*zV>4tpDm
z9wSwfJNWn7?Ayr$gLWunD~U+LNXU7qs;qgXKRm2*YN!A{&OVV3SMeSi?pA-P_Cn_G
z4Kh*(1qowp2_SDufMJr~E?j`w08J6}#!~oPIFur{r3)FMv9RSutp)B2Zi~tq5rX*P
z6c!t^O*rsP;B~h2_+F~Ra~^XVFz>c>F)}w2Kve-a*GrcsBC<=@7b1*E0AryF`ewE9
zHQv{$PK37&NPc2?Unf2hocLM_wRE;Af@Ws$(u<-oudMUyBknBJR*~~wapy%!`)w4V
z){0P0{0qw0$~%v_wD!)U=0$aXH|CrYi&ktlpkJS05%dT|Y{eEP{ZG0=XwiA55T$_>
R0RlmR%MA$PWm)0Z{{ZksFq8lQ
literal 0
HcmV?d00001
diff --git a/version5/krpc-consumer/target/maven-archiver/pom.properties b/version5/krpc-consumer/target/maven-archiver/pom.properties
new file mode 100644
index 0000000..96d4f06
--- /dev/null
+++ b/version5/krpc-consumer/target/maven-archiver/pom.properties
@@ -0,0 +1,5 @@
+#Generated by Maven
+#Thu Dec 05 15:19:00 CST 2024
+groupId=com.kama
+artifactId=krpc-consumer
+version=1.0-SNAPSHOT
diff --git a/version5/krpc-consumer/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst b/version5/krpc-consumer/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
new file mode 100644
index 0000000..e3ec4a4
--- /dev/null
+++ b/version5/krpc-consumer/target/maven-status/maven-compiler-plugin/compile/default-compile/createdFiles.lst
@@ -0,0 +1,2 @@
+com\kama\ConsumerTestConfig.class
+com\kama\ConsumerApplication.class
diff --git a/version5/krpc-consumer/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst b/version5/krpc-consumer/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
new file mode 100644
index 0000000..08a64ca
--- /dev/null
+++ b/version5/krpc-consumer/target/maven-status/maven-compiler-plugin/compile/default-compile/inputFiles.lst
@@ -0,0 +1,2 @@
+D:\java_stduy\version5\krpc-consumer\src\main\java\com\kama\ConsumerTestConfig.java
+D:\java_stduy\version5\krpc-consumer\src\main\java\com\kama\ConsumerApplication.java
diff --git a/version5/krpc-core/pom.xml b/version5/krpc-core/pom.xml
new file mode 100644
index 0000000..f0a7710
--- /dev/null
+++ b/version5/krpc-core/pom.xml
@@ -0,0 +1,114 @@
+
+
+ 4.0.0
+
+ com.kama
+ version5
+ 1.0-SNAPSHOT
+
+
+ krpc-core
+
+
+ 17
+ 17
+ UTF-8
+
+
+
+ com.kama
+ krpc-common
+ 1.0-SNAPSHOT
+
+
+ org.projectlombok
+ lombok
+ 1.18.30
+ compile
+
+
+ io.netty
+ netty-all
+ 4.1.51.Final
+ compile
+
+
+
+ org.apache.curator
+ curator-recipes
+ 5.1.0
+
+
+ com.alibaba
+ fastjson
+ 1.2.83
+
+
+ com.esotericsoftware
+ kryo
+ 4.0.2
+
+
+ com.caucho
+ hessian
+ 4.0.66
+
+
+ io.protostuff
+ protostuff-core
+ 1.7.4
+
+
+ io.protostuff
+ protostuff-runtime
+ 1.7.4
+
+
+ com.github.rholder
+ guava-retrying
+ 2.0.0
+
+
+ org.jetbrains
+ annotations
+ 17.0.0
+ compile
+
+
+ com.kama
+ krpc-api
+ 1.0-SNAPSHOT
+
+
+ cn.hutool
+ hutool-all
+ 5.8.10
+
+
+
+ org.junit.jupiter
+ junit-jupiter-api
+ 5.11.3
+ test
+
+
+ org.junit.jupiter
+ junit-jupiter-engine
+ 5.11.3
+ test
+
+
+
+ org.junit.platform
+ junit-platform-launcher
+ 1.11.3
+ test
+
+
+ junit
+ junit
+
+
+
\ No newline at end of file
diff --git a/version5/krpc-core/src/main/java/com/kama/KRpcApplication.java b/version5/krpc-core/src/main/java/com/kama/KRpcApplication.java
new file mode 100644
index 0000000..9529f74
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/KRpcApplication.java
@@ -0,0 +1,48 @@
+package com.kama;
+
+
+import com.kama.config.KRpcConfig;
+import com.kama.config.RpcConstant;
+import common.util.ConfigUtil;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * @ClassName RpcApplication
+ * @Description 测试配置顶，学习更多参考Dubbo
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 11:22
+ * @Version v5.0
+ */
+@Slf4j
+public class KRpcApplication {
+ private static volatile KRpcConfig rpcConfigInstance;
+
+ public static void initialize(KRpcConfig customRpcConfig) {
+ rpcConfigInstance = customRpcConfig;
+ log.info("RPC 框架初始化，配置 = {}", customRpcConfig);
+ }
+
+ public static void initialize() {
+ KRpcConfig customRpcConfig;
+ try {
+ customRpcConfig = ConfigUtil.loadConfig(KRpcConfig.class, RpcConstant.CONFIG_FILE_PREFIX);
+ log.info("成功加载配置文件，配置文件名称 = {}", RpcConstant.CONFIG_FILE_PREFIX); // 添加成功加载的日志
+ } catch (Exception e) {
+ // 配置加载失败，使用默认配置
+ customRpcConfig = new KRpcConfig();
+ log.warn("配置加载失败，使用默认配置");
+ }
+ initialize(customRpcConfig);
+ }
+
+ public static KRpcConfig getRpcConfig() {
+ if (rpcConfigInstance == null) {
+ synchronized (KRpcApplication.class) {
+ if (rpcConfigInstance == null) {
+ initialize(); // 确保在第一次调用时初始化
+ }
+ }
+ }
+ return rpcConfigInstance;
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/cache/ServiceCache.java b/version5/krpc-core/src/main/java/com/kama/client/cache/ServiceCache.java
new file mode 100644
index 0000000..8eba240
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/cache/ServiceCache.java
@@ -0,0 +1,75 @@
+package com.kama.client.cache;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.ArrayList;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @ClassName serviceCache
+ * @Description 建立本地缓存
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:34
+ * @Version v5.0
+ */
+@Slf4j
+public class ServiceCache {
+ //key: serviceName 服务名
+ //value： addressList 服务提供者列表
+ private static Map> cache = new ConcurrentHashMap<>();
+
+ //添加服务
+ public void addServiceToCache(String serviceName, String address) {
+ if (cache.containsKey(serviceName)) {
+ List addressList = cache.get(serviceName);
+ addressList.add(address);
+ log.info("有服务名情况，将name为{}和地址为{}的服务添加到本地缓存中", serviceName, address);
+ } else {
+ List addressList = new ArrayList<>();
+ addressList.add(address);
+ cache.put(serviceName, addressList);
+ log.info("无服务名情况，将name为{}和地址为{}的服务添加到本地缓存中", serviceName, address);
+ }
+ }
+
+ //修改服务地址
+ public void replaceServiceAddress(String serviceName, String oldAddress, String newAddress) {
+ if (cache.containsKey(serviceName)) {
+ List addressList = cache.get(serviceName);
+ addressList.remove(oldAddress);
+ addressList.add(newAddress);
+ log.info("将服务{}的地址{}替换为{}", serviceName, oldAddress, newAddress);
+ } else {
+ log.error("旧地址{}不在服务{}的地址列表中", oldAddress, serviceName);
+ }
+ }
+
+ //从缓存中取服务地址列表
+ public List getServiceListFromCache(String serviceName) {
+ if (!cache.containsKey(serviceName)) {
+ log.warn("服务{}未找到", serviceName);
+ //返回个不可修改的空列表，避免调用的时候出现空指针异常
+ return Collections.emptyList();
+ }
+ return cache.get(serviceName);
+ }
+
+ //从缓存中删除服务地址
+ public void delete(String serviceName, String address) {
+ List addressList = cache.get(serviceName);
+ if (addressList != null && addressList.contains(address)) {
+ addressList.remove(address);
+ log.info("将name为{}和地址为{}的服务从本地缓存中删除", serviceName, address);
+ if (addressList.isEmpty()) {
+ cache.remove(serviceName); // 移除该服务的缓存条目
+ log.info("服务{}的地址列表为空，已从缓存中清除", serviceName);
+ }
+ } else {
+ log.warn("删除失败，地址{}不在服务{}的地址列表中", address, serviceName);
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/circuitbreaker/CircuitBreaker.java b/version5/krpc-core/src/main/java/com/kama/client/circuitbreaker/CircuitBreaker.java
new file mode 100644
index 0000000..53a6489
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/circuitbreaker/CircuitBreaker.java
@@ -0,0 +1,109 @@
+package com.kama.client.circuitbreaker;
+
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @ClassName CircuitBreaker
+ * @Description 熔断器的状态
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:45
+ * @Version v5.0
+ */
+@Slf4j
+public class CircuitBreaker {
+ //当前状态
+ private CircuitBreakerState state = CircuitBreakerState.CLOSED;
+ private AtomicInteger failureCount = new AtomicInteger(0);
+ private AtomicInteger successCount = new AtomicInteger(0);
+ private AtomicInteger requestCount = new AtomicInteger(0);
+ //失败次数阈值
+ private final int failureThreshold;
+ //半开启-》关闭状态的成功次数比例
+ private final double halfOpenSuccessRate;
+ //恢复时间
+ private final long retryTimePeriod;
+ //上一次失败时间
+ private long lastFailureTime = 0;
+
+ public CircuitBreaker(int failureThreshold, double halfOpenSuccessRate, long retryTimePeriod) {
+ this.failureThreshold = failureThreshold;
+ this.halfOpenSuccessRate = halfOpenSuccessRate;
+ this.retryTimePeriod = retryTimePeriod;
+ }
+
+ //查看当前熔断器是否允许请求通过
+ public synchronized boolean allowRequest() {
+ long currentTime = System.currentTimeMillis();
+ log.info("熔断前检查, 当前失败次数：{}", failureCount);
+ switch (state) {
+ case OPEN:
+ if (currentTime - lastFailureTime > retryTimePeriod) {
+ state = CircuitBreakerState.HALF_OPEN;
+ resetCounts();
+ log.info("熔断已解除，进入半开启状态，允许请求通过");
+ return true;
+ }
+ log.warn("熔断生效中，拒绝请求！");
+ return false;
+ case HALF_OPEN:
+ requestCount.incrementAndGet();
+ log.info("当前为半开启状态，计数请求");
+ return true;
+ case CLOSED:
+ default:
+ log.info("当前为正常状态，允许请求通过");
+ return true;
+ }
+ }
+
+ //记录成功
+ public synchronized void recordSuccess() {
+ if (state == CircuitBreakerState.HALF_OPEN) {
+ successCount.incrementAndGet();
+ if (successCount.get() >= halfOpenSuccessRate * requestCount.get()) {
+ state = CircuitBreakerState.CLOSED;
+ resetCounts();
+ log.info("成功次数已达到阈值，熔断器切换至关闭状态");
+ }
+ } else {
+ resetCounts();
+ log.info("熔断器处于关闭状态，重置计数器");
+ }
+ }
+
+ //记录失败
+ public synchronized void recordFailure() {
+ failureCount.incrementAndGet();
+ log.error("记录失败，当前失败次数：{}", failureCount);
+ lastFailureTime = System.currentTimeMillis();
+
+ if (state == CircuitBreakerState.HALF_OPEN) {
+ state = CircuitBreakerState.OPEN;
+ lastFailureTime = System.currentTimeMillis();
+ log.warn("半开启状态下发生失败，熔断器切换至开启状态");
+ } else if (failureCount.get() >= failureThreshold) {
+ state = CircuitBreakerState.OPEN;
+ log.error("失败次数已超过阈值，熔断器切换至开启状态");
+ }
+ }
+
+ //重置次数
+ private void resetCounts() {
+ failureCount.set(0);
+ successCount.set(0);
+ requestCount.set(0);
+ }
+
+ public CircuitBreakerState getState() {
+ return state;
+ }
+}
+
+enum CircuitBreakerState {
+ //关闭，开启，半开启
+ CLOSED, OPEN, HALF_OPEN
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/circuitbreaker/CircuitBreakerProvider.java b/version5/krpc-core/src/main/java/com/kama/client/circuitbreaker/CircuitBreakerProvider.java
new file mode 100644
index 0000000..f94bf5c
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/circuitbreaker/CircuitBreakerProvider.java
@@ -0,0 +1,28 @@
+package com.kama.client.circuitbreaker;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @ClassName CircuitBreakerState
+ * @Description 提供熔断器
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:47
+ * @Version v5.0
+ */
+@Slf4j
+public class CircuitBreakerProvider {
+ // 使用线程安全的 ConcurrentHashMap
+ private Map circuitBreakerMap = new ConcurrentHashMap<>();
+
+ public synchronized CircuitBreaker getCircuitBreaker(String serviceName) {
+ // 使用 computeIfAbsent，避免手动同步
+ return circuitBreakerMap.computeIfAbsent(serviceName, key -> {
+ log.info("服务 [{}] 不存在熔断器，创建新的熔断器实例", serviceName);
+ // 创建并返回新熔断器
+ return new CircuitBreaker(1, 0.5, 10000);
+ });
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/netty/NettyClientHandler.java b/version5/krpc-core/src/main/java/com/kama/client/netty/NettyClientHandler.java
new file mode 100644
index 0000000..15c98ff
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/netty/NettyClientHandler.java
@@ -0,0 +1,34 @@
+package com.kama.client.netty;
+
+import common.message.RpcResponse;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import io.netty.util.AttributeKey;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * @ClassName NettyClientHandler
+ * @Description 客户端处理器
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:15
+ * @Version v5.0
+ */
+@Slf4j
+public class NettyClientHandler extends SimpleChannelInboundHandler {
+
+
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, RpcResponse response) throws Exception {
+ // 接收到response, 给channel设计别名，让sendRequest里读取response
+ AttributeKey RESPONSE_KEY = AttributeKey.valueOf("RPCResponse");
+ // 将响应存入 Channel 属性
+ ctx.channel().attr(RESPONSE_KEY).set(response);
+ ctx.channel().close();
+ }
+
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+ log.error("Channel exception occurred", cause);
+ ctx.close();
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/netty/NettyClientInitializer.java b/version5/krpc-core/src/main/java/com/kama/client/netty/NettyClientInitializer.java
new file mode 100644
index 0000000..3836d7e
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/netty/NettyClientInitializer.java
@@ -0,0 +1,40 @@
+package com.kama.client.netty;
+
+
+import common.serializer.mycoder.MyDecoder;
+import common.serializer.mycoder.MyEncoder;
+import common.serializer.myserializer.Serializer;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.socket.SocketChannel;
+import lombok.extern.slf4j.Slf4j;
+
+/**
+ * @ClassName NettyClientInitializer
+ * @Description 配置自定义的编码器以及Handler
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:16
+ * @Version v5.0
+ */
+@Slf4j
+public class NettyClientInitializer extends ChannelInitializer {
+
+
+ @Override
+ protected void initChannel(SocketChannel ch) throws Exception {
+ ChannelPipeline pipeline = ch.pipeline();
+
+ // 使用自定义的编码器和解码器
+ try {
+ // 根据传入的序列化器类型初始化编码器
+ pipeline.addLast(new MyEncoder(Serializer.getSerializerByCode(3)));
+ pipeline.addLast(new MyDecoder());
+ pipeline.addLast(new NettyClientHandler());
+
+ log.info("Netty client pipeline initialized with serializer type: {}",Serializer.getSerializerByCode(3).toString());
+ } catch (Exception e) {
+ log.error("Error initializing Netty client pipeline", e);
+ throw e; // 重新抛出异常，确保管道初始化失败时处理正确
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/proxy/ClientProxy.java b/version5/krpc-core/src/main/java/com/kama/client/proxy/ClientProxy.java
new file mode 100644
index 0000000..ef3f6e8
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/proxy/ClientProxy.java
@@ -0,0 +1,92 @@
+package com.kama.client.proxy;
+
+import com.kama.client.circuitbreaker.CircuitBreaker;
+import com.kama.client.circuitbreaker.CircuitBreakerProvider;
+import com.kama.client.retry.GuavaRetry;
+import com.kama.client.rpcclient.RpcClient;
+import com.kama.client.rpcclient.impl.NettyRpcClient;
+import com.kama.client.servicecenter.ServiceCenter;
+import com.kama.client.servicecenter.ZKServiceCenter;
+
+
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+import lombok.extern.slf4j.Slf4j;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+/**
+ * @ClassName ClientProxy
+ * @Description 动态代理
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:14
+ * @Version v5.0
+ */
+@Slf4j
+public class ClientProxy implements InvocationHandler {
+ //传入参数service接口的class对象，反射封装成一个request
+
+ private RpcClient rpcClient;
+ private ServiceCenter serviceCenter;
+ private CircuitBreakerProvider circuitBreakerProvider;
+
+ public ClientProxy() throws InterruptedException {
+ serviceCenter = new ZKServiceCenter();
+ rpcClient = new NettyRpcClient(serviceCenter);
+ circuitBreakerProvider = new CircuitBreakerProvider();
+ }
+
+ //jdk动态代理，每一次代理对象调用方法，都会经过此方法增强（反射获取request对象，socket发送到服务端）
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ //构建request
+ RpcRequest request = RpcRequest.builder()
+ .interfaceName(method.getDeclaringClass().getName())
+ .methodName(method.getName())
+ .params(args).paramsType(method.getParameterTypes()).build();
+ //获取熔断器
+ CircuitBreaker circuitBreaker = circuitBreakerProvider.getCircuitBreaker(method.getName());
+ //判断熔断器是否允许请求经过
+ if (!circuitBreaker.allowRequest()) {
+ log.warn("熔断器开启，请求被拒绝: {}", request);
+ //这里可以针对熔断做特殊处理，返回特殊值
+ return null;
+ }
+ //数据传输
+ RpcResponse response;
+ //后续添加逻辑：为保持幂等性，只对白名单上的服务进行重试
+ // 如果启用重试机制，先检查是否需要重试
+ if (serviceCenter.checkRetry(request.getInterfaceName())) {
+ //调用retry框架进行重试操作
+ try {
+ log.info("尝试重试调用服务: {}", request.getInterfaceName());
+ response = new GuavaRetry().sendServiceWithRetry(request, rpcClient);
+ } catch (Exception e) {
+ log.error("重试调用失败: {}", request.getInterfaceName(), e);
+ circuitBreaker.recordFailure();
+ throw e; // 将异常抛给调用者
+ }
+ } else {
+ //只调用一次
+ response = rpcClient.sendRequest(request);
+ }
+ //记录response的状态，上报给熔断器
+ if (response != null) {
+ if (response.getCode() == 200) {
+ circuitBreaker.recordSuccess();
+ } else if (response.getCode() == 500) {
+ circuitBreaker.recordFailure();
+ }
+ log.info("收到响应: {} 状态码: {}", request.getInterfaceName(), response.getCode());
+ }
+
+ return response != null ? response.getData() : null;
+ }
+
+ public T getProxy(Class clazz) {
+ Object o = Proxy.newProxyInstance(clazz.getClassLoader(), new Class[]{clazz}, this);
+ return (T) o;
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/retry/GuavaRetry.java b/version5/krpc-core/src/main/java/com/kama/client/retry/GuavaRetry.java
new file mode 100644
index 0000000..0d1dde1
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/retry/GuavaRetry.java
@@ -0,0 +1,48 @@
+package com.kama.client.retry;
+
+import com.kama.client.rpcclient.RpcClient;
+import com.github.rholder.retry.*;
+
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+import lombok.extern.slf4j.Slf4j;
+
+
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * @ClassName guavaRetry
+ * @Description 重试策略
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:44
+ * @Version v5.0
+ */
+@Slf4j
+public class GuavaRetry {
+
+ public RpcResponse sendServiceWithRetry(RpcRequest request, RpcClient rpcClient) {
+ Retryer retryer = RetryerBuilder.newBuilder()
+ //无论出现什么异常，都进行重试
+ .retryIfException()
+ //返回结果为 error时进行重试
+ .retryIfResult(response -> Objects.equals(response.getCode(), 500))
+ //重试等待策略：等待 2s 后再进行重试
+ .withWaitStrategy(WaitStrategies.fixedWait(2, TimeUnit.SECONDS))
+ //重试停止策略：重试达到 3 次
+ .withStopStrategy(StopStrategies.stopAfterAttempt(3))
+ .withRetryListener(new RetryListener() {
+ @Override
+ public void onRetry(Attempt attempt) {
+ log.info("重试第 {} 次", attempt.getAttemptNumber());
+ }
+ })
+ .build();
+ try {
+ return retryer.call(() -> rpcClient.sendRequest(request));
+ } catch (Exception e) {
+ log.error("重试失败: 请求 {} 执行时遇到异常", request.getMethodName(), e);
+ }
+ return RpcResponse.fail("重试失败，所有重试尝试已结束");
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/rpcclient/RpcClient.java b/version5/krpc-core/src/main/java/com/kama/client/rpcclient/RpcClient.java
new file mode 100644
index 0000000..80a4255
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/rpcclient/RpcClient.java
@@ -0,0 +1,17 @@
+package com.kama.client.rpcclient;
+
+
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+
+/**
+ * @InterfaceName RpcClient
+ * @Description 定义底层通信方法
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:11
+ * @Version v5.0
+ */
+
+public interface RpcClient {
+ RpcResponse sendRequest(RpcRequest request);
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/rpcclient/impl/NettyRpcClient.java b/version5/krpc-core/src/main/java/com/kama/client/rpcclient/impl/NettyRpcClient.java
new file mode 100644
index 0000000..7bd2e75
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/rpcclient/impl/NettyRpcClient.java
@@ -0,0 +1,103 @@
+package com.kama.client.rpcclient.impl;
+
+import com.kama.client.netty.NettyClientInitializer;
+import com.kama.client.rpcclient.RpcClient;
+import com.kama.client.servicecenter.ServiceCenter;
+
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+import io.netty.bootstrap.Bootstrap;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.EventLoopGroup;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.util.AttributeKey;
+import lombok.extern.slf4j.Slf4j;
+
+
+import java.net.InetSocketAddress;
+
+/**
+ * @ClassName NettyRpcClient
+ * @Description Netty客户端
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 11:03
+ * @Version v5.0
+ */
+@Slf4j
+public class NettyRpcClient implements RpcClient {
+
+ private static final Bootstrap bootstrap;
+ private static final EventLoopGroup eventLoopGroup;
+
+ private ServiceCenter serviceCenter;
+
+ public NettyRpcClient(ServiceCenter serviceCenter) throws InterruptedException {
+ this.serviceCenter = serviceCenter;
+ }
+
+ //netty客户端初始化
+ static {
+ eventLoopGroup = new NioEventLoopGroup();
+ bootstrap = new Bootstrap();
+ bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
+ .handler(new NettyClientInitializer());
+ }
+
+ @Override
+ public RpcResponse sendRequest(RpcRequest request) {
+ //从注册中心获取host,post
+ InetSocketAddress address = serviceCenter.serviceDiscovery(request.getInterfaceName());
+ if (address == null) {
+ log.error("服务发现失败，返回的地址为 null");
+ return RpcResponse.fail("服务发现失败，地址为 null");
+ }
+ String host = address.getHostName();
+ int port = address.getPort();
+ try {
+ // 连接到远程服务
+ ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
+ Channel channel = channelFuture.channel();
+ // 发送数据
+ channel.writeAndFlush(request);
+ //sync()堵塞获取结果
+ channel.closeFuture().sync();
+ // 阻塞的获得结果，通过给channel设计别名，获取特定名字下的channel中的内容（这个在hanlder中设置）
+ // AttributeKey是，线程隔离的，不会由线程安全问题。
+ // 当前场景下选择堵塞获取结果
+ // 其它场景也可以选择添加监听器的方式来异步获取结果 channelFuture.addListener...
+ AttributeKey key = AttributeKey.valueOf("RPCResponse");
+ RpcResponse response = channel.attr(key).get();
+
+ if (response == null) {
+ log.error("服务响应为空，可能是请求失败或超时");
+ return RpcResponse.fail("服务响应为空");
+ }
+
+ log.info("收到响应: {}", response);
+ return response;
+ } catch (InterruptedException e) {
+ log.error("请求被中断，发送请求失败: {}", e.getMessage(), e);
+ Thread.currentThread().interrupt();
+ } catch (Exception e) {
+ log.error("发送请求时发生异常: {}", e.getMessage(), e);
+ } finally {
+ // 连接断开后，优雅地关闭 Netty 资源
+ shutdown();
+ }
+ return RpcResponse.fail("请求失败");
+ }
+
+ // 优雅关闭 Netty 资源
+ private void shutdown() {
+ try {
+ if (eventLoopGroup != null) {
+ eventLoopGroup.shutdownGracefully().sync();
+ }
+ } catch (InterruptedException e) {
+ log.error("关闭 Netty 资源时发生异常: {}", e.getMessage(), e);
+ Thread.currentThread().interrupt();
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/rpcclient/impl/SimpleSocketRpcClient.java b/version5/krpc-core/src/main/java/com/kama/client/rpcclient/impl/SimpleSocketRpcClient.java
new file mode 100644
index 0000000..589cc98
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/rpcclient/impl/SimpleSocketRpcClient.java
@@ -0,0 +1,57 @@
+package com.kama.client.rpcclient.impl;
+
+import com.kama.client.rpcclient.RpcClient;
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+/**
+ * @ClassName SimpleSocketRpcClient
+ * @Description 实现简单客户都
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:12
+ * @Version v5.0
+ */
+public class SimpleSocketRpcClient implements RpcClient {
+ private String host;
+ private int port;
+
+ public SimpleSocketRpcClient(String host, int port) {
+ this.host = host;
+ this.port = port;
+ }
+
+ @Override
+ public RpcResponse sendRequest(RpcRequest request) {
+ // 定义响应对象
+ RpcResponse response = null;
+
+ // 创建 Socket 和流对象
+ try (Socket socket = new Socket(host, port);
+ ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
+ ObjectInputStream ois = new ObjectInputStream(socket.getInputStream())) {
+
+ // 发送请求对象
+ oos.writeObject(request);
+ oos.flush();
+
+ // 接收响应对象
+ response = (RpcResponse) ois.readObject();
+
+ } catch (UnknownHostException e) {
+ System.err.println("未知的主机: " + host);
+ } catch (IOException e) {
+ System.err.println("I/O 错误: " + e.getMessage());
+ } catch (ClassNotFoundException e) {
+ System.err.println("无法识别的类: " + e.getMessage());
+ }
+
+ return response;
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ServiceCenter.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ServiceCenter.java
new file mode 100644
index 0000000..f1aa801
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ServiceCenter.java
@@ -0,0 +1,20 @@
+package com.kama.client.servicecenter;
+
+
+import java.net.InetSocketAddress;
+
+/**
+ * @InterfaceName ServiceCenter
+ * @Description 服务中心接口
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:31
+ * @Version v5.0
+ */
+
+public interface ServiceCenter {
+ // 查询：根据服务名查找地址
+ InetSocketAddress serviceDiscovery(String serviceName);
+
+ //判断是否可重试
+ boolean checkRetry(String serviceName);
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ZKServiceCenter.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ZKServiceCenter.java
new file mode 100644
index 0000000..93f2701
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ZKServiceCenter.java
@@ -0,0 +1,113 @@
+package com.kama.client.servicecenter;
+
+import com.kama.client.cache.ServiceCache;
+import com.kama.client.servicecenter.ZKWatcher.watchZK;
+import com.kama.client.servicecenter.balance.LoadBalance;
+import com.kama.client.servicecenter.balance.impl.ConsistencyHashBalance;
+import com.kama.client.servicecenter.balance.impl.RandomLoadBalance;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.curator.RetryPolicy;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.CuratorFrameworkFactory;
+import org.apache.curator.retry.ExponentialBackoffRetry;
+
+import java.net.InetSocketAddress;
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.CopyOnWriteArraySet;
+
+/**
+ * @ClassName ZKServiceCenter
+ * @Description 从服务中心获取服务地址
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:33
+ * @Version v5.0
+ */
+@Slf4j
+public class ZKServiceCenter implements ServiceCenter {
+ // curator 提供的zookeeper客户端
+ private CuratorFramework client;
+ //zookeeper根路径节点
+ private static final String ROOT_PATH = "MyRPC";
+ private static final String RETRY = "CanRetry";
+ //serviceCache
+ private ServiceCache cache;
+
+ private final LoadBalance loadBalance = new ConsistencyHashBalance();
+
+ //负责zookeeper客户端的初始化，并与zookeeper服务端进行连接
+ public ZKServiceCenter() throws InterruptedException {
+ // 指数时间重试
+ RetryPolicy policy = new ExponentialBackoffRetry(1000, 3);
+ // zookeeper的地址固定，不管是服务提供者还是，消费者都要与之建立连接
+ // sessionTimeoutMs 与 zoo.cfg中的tickTime 有关系，
+ // zk还会根据minSessionTimeout与maxSessionTimeout两个参数重新调整最后的超时值。默认分别为tickTime 的2倍和20倍
+ // 使用心跳监听状态
+ this.client = CuratorFrameworkFactory.builder().connectString("127.0.0.1:2181")
+ .sessionTimeoutMs(40000).retryPolicy(policy).namespace(ROOT_PATH).build();
+ this.client.start();
+ log.info("Zookeeper 连接成功");
+ //初始化本地缓存
+ cache = new ServiceCache();
+ //加入zookeeper事件监听器
+ watchZK watcher = new watchZK(client, cache);
+ //监听启动
+ watcher.watchToUpdate(ROOT_PATH);
+ }
+
+ //根据服务名（接口名）返回地址
+ @Override
+ public InetSocketAddress serviceDiscovery(String serviceName) {
+ try {
+ //先从本地缓存中找
+ List addressList = cache.getServiceListFromCache(serviceName);
+ //如果找不到，再去zookeeper中找
+ //这种i情况基本不会发生，或者说只会出现在初始化阶段
+ if (addressList == null) {
+ addressList = client.getChildren().forPath("/" + serviceName);
+ // 如果本地缓存中没有该服务名的地址列表，则添加
+ List cachedAddresses = cache.getServiceListFromCache(serviceName);
+ if (cachedAddresses == null || cachedAddresses.isEmpty()) {
+ // 假设 addServiceToCache 方法可以处理单个地址
+ for (String address : addressList) {
+ cache.addServiceToCache(serviceName, address);
+ }
+ }
+ }
+ if (addressList.isEmpty()) {
+ log.warn("未找到服务：{}", serviceName);
+ return null;
+ }
+ // 负载均衡得到地址
+ String address = loadBalance.balance(addressList);
+ return parseAddress(address);
+ } catch (Exception e) {
+ log.error("服务发现失败，服务名：{}", serviceName, e);
+ }
+ return null;
+ }
+ //保证线程安全使用CopyOnWriteArraySet
+ private Set retryServiceCache = new CopyOnWriteArraySet<>();
+ //写一个白名单缓存，优化性能
+ public boolean checkRetry(String serviceName) {
+ // 如果缓存为空，则从 Zookeeper 中加载白名单
+ if (retryServiceCache.isEmpty()) {
+ try {
+ // 获取 Zookeeper 上的 /RETRY 路径下的所有子节点（服务名称）
+ List serviceList = client.getChildren().forPath("/" + RETRY);
+ // 将从 Zookeeper 获取到的服务名称列表添加到缓存中
+ retryServiceCache.addAll(serviceList);
+ } catch (Exception e) {
+ log.error("检查重试失败，服务名：{}", serviceName, e);
+ }
+ }
+ // 判断服务是否在缓存的白名单中
+ return retryServiceCache.contains(serviceName);
+ }
+
+ // 字符串解析为地址
+ private InetSocketAddress parseAddress(String address) {
+ String[] result = address.split(":");
+ return new InetSocketAddress(result[0], Integer.parseInt(result[1]));
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ZKWatcher/watchZK.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ZKWatcher/watchZK.java
new file mode 100644
index 0000000..396d4e8
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/ZKWatcher/watchZK.java
@@ -0,0 +1,98 @@
+package com.kama.client.servicecenter.ZKWatcher;
+
+import com.kama.client.cache.ServiceCache;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.recipes.cache.ChildData;
+import org.apache.curator.framework.recipes.cache.CuratorCache;
+import org.apache.curator.framework.recipes.cache.CuratorCacheListener;
+
+
+/**
+ * @ClassName watchZK
+ * @Description 节点监听
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:37
+ * @Version v5.0
+ */
+@Slf4j
+public class watchZK {
+ // curator 提供的zookeeper客户端
+ private CuratorFramework client;
+ //本地缓存
+ ServiceCache cache;
+
+
+ public watchZK(CuratorFramework client, ServiceCache cache) {
+ this.client = client;
+ this.cache = cache;
+ }
+
+ /**
+ * 监听当前节点和子节点的 更新，创建，删除
+ *
+ * @param path
+ */
+ public void watchToUpdate(String path) throws InterruptedException {
+ CuratorCache curatorCache = CuratorCache.build(client, "/");
+ curatorCache.listenable().addListener(new CuratorCacheListener() {
+ @Override
+ public void event(Type type, ChildData childData, ChildData childData1) {
+ // 第一个参数：事件类型（枚举）
+ // 第二个参数：节点更新前的状态、数据
+ // 第三个参数：节点更新后的状态、数据
+ // 创建节点时：节点刚被创建，不存在 更新前节点 ，所以第二个参数为 null
+ // 删除节点时：节点被删除，不存在 更新后节点 ，所以第三个参数为 null
+ // 节点创建时没有赋予值 create /curator/app1 只创建节点，在这种情况下，更新前节点的 data 为 null，获取不到更新前节点的数据
+ switch (type.name()) {
+ case "NODE_CREATED": // 监听器第一次执行时节点存在也会触发次事件
+ String[] pathList = pasrePath(childData1);
+ if (pathList.length <= 2) break;
+ else {
+ String serviceName = pathList[1];
+ String address = pathList[2];
+ //将新注册的服务加入到本地缓存中
+ cache.addServiceToCache(serviceName, address);
+ log.info("节点创建：服务名称 {} 地址 {}", serviceName, address);
+ }
+ break;
+ case "NODE_CHANGED": // 节点更新
+ if (childData.getData() != null) {
+ log.debug("修改前的数据: {}", new String(childData.getData()));
+ } else {
+ log.debug("节点第一次赋值!");
+ }
+ String[] oldPathList = pasrePath(childData);
+ String[] newPathList = pasrePath(childData1);
+ cache.replaceServiceAddress(oldPathList[1], oldPathList[2], newPathList[2]);
+ log.info("节点更新：服务名称 {} 地址从 {} 更新为 {}", oldPathList[1], oldPathList[2], newPathList[2]);
+ break;
+ case "NODE_DELETED": // 节点删除
+ String[] pathList_d = pasrePath(childData);
+ if (pathList_d.length <= 2) break;
+ else {
+ String serviceName = pathList_d[1];
+ String address = pathList_d[2];
+ //将新注册的服务加入到本地缓存中
+ cache.delete(serviceName, address);
+ log.info("节点删除：服务名称 {} 地址 {}", serviceName, address);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ });
+ //开启监听
+ curatorCache.start();
+ }
+
+ //解析节点对应地址
+ public String[] pasrePath(ChildData childData) {
+ //获取更新的节点的路径
+ String path = new String(childData.getPath());
+ log.info("节点路径:{}",path);
+ //按照格式 ，读取
+ return path.split("/");
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/LoadBalance.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/LoadBalance.java
new file mode 100644
index 0000000..1f1742c
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/LoadBalance.java
@@ -0,0 +1,20 @@
+package com.kama.client.servicecenter.balance;
+
+
+import java.util.List;
+
+/**
+ * @InterfaceName LoadBalance
+ * @Description 负载均衡接口
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:40
+ * @Version v5.0
+ */
+
+public interface LoadBalance {
+ String balance(List addressList);
+
+ void addNode(String node);
+
+ void delNode(String node);
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/ConsistencyHashBalance.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/ConsistencyHashBalance.java
new file mode 100644
index 0000000..119b9ea
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/ConsistencyHashBalance.java
@@ -0,0 +1,152 @@
+package com.kama.client.servicecenter.balance.impl;
+
+import com.kama.client.servicecenter.balance.LoadBalance;
+import lombok.extern.slf4j.Slf4j;
+
+
+import java.util.*;
+import java.util.concurrent.ConcurrentSkipListMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * @ClassName ConsistencyHashBalance
+ * @Description 一致性哈希算法负载均衡
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:42
+ * @Version v5.0
+ */
+@Slf4j
+public class ConsistencyHashBalance implements LoadBalance {
+
+ // 虚拟节点的个数
+ private static final int VIRTUAL_NUM = 5;
+
+ // 虚拟节点分配，key是hash值，value是虚拟节点服务器名称
+ private SortedMap shards = new TreeMap();
+
+ // 真实节点列表
+ private List realNodes = new LinkedList<>();
+
+ // 获取虚拟节点的个数
+ public static int getVirtualNum() {
+ return VIRTUAL_NUM;
+ }
+
+ // 初始化虚拟节点
+ public void init(List serviceList) {
+ for (String server : serviceList) {
+ realNodes.add(server);
+ log.info("真实节点[{}] 被添加", server);
+ for (int i = 0; i < VIRTUAL_NUM; i++) {
+ String virtualNode = server + "&&VN" + i;
+ int hash = getHash(virtualNode);
+ shards.put(hash, virtualNode);
+ log.info("虚拟节点[{}] hash:{}，被添加", virtualNode, hash);
+ }
+ }
+ }
+
+ /**
+ * 获取被分配的节点名
+ *
+ * @param node 请求的节点（通常是请求的唯一标识符）
+ * @return 负责该请求的真实节点名称
+ */
+ public String getServer(String node, List serviceList) {
+ if (shards.isEmpty()) {
+ init(serviceList); // 初始化，如果shards为空
+ }
+
+ int hash = getHash(node);
+ Integer key = null;
+
+ SortedMap subMap = shards.tailMap(hash);
+ if (subMap.isEmpty()) {
+ key = shards.firstKey(); // 如果没有大于该hash的节点，则返回最小的hash值
+ } else {
+ key = subMap.firstKey();
+ }
+
+ String virtualNode = shards.get(key);
+ return virtualNode.substring(0, virtualNode.indexOf("&&"));
+ }
+
+ /**
+ * 添加节点
+ *
+ * @param node 新加入的节点
+ */
+ public void addNode(String node) {
+ if (!realNodes.contains(node)) {
+ realNodes.add(node);
+ log.info("真实节点[{}] 上线添加", node);
+ for (int i = 0; i < VIRTUAL_NUM; i++) {
+ String virtualNode = node + "&&VN" + i;
+ int hash = getHash(virtualNode);
+ shards.put(hash, virtualNode);
+ log.info("虚拟节点[{}] hash:{}，被添加", virtualNode, hash);
+ }
+ }
+ }
+
+ /**
+ * 删除节点
+ *
+ * @param node 被移除的节点
+ */
+ public void delNode(String node) {
+ if (realNodes.contains(node)) {
+ realNodes.remove(node);
+ log.info("真实节点[{}] 下线移除", node);
+ for (int i = 0; i < VIRTUAL_NUM; i++) {
+ String virtualNode = node + "&&VN" + i;
+ int hash = getHash(virtualNode);
+ shards.remove(hash);
+ log.info("虚拟节点[{}] hash:{}，被移除", virtualNode, hash);
+ }
+ }
+ }
+
+ /**
+ * FNV1_32_HASH算法
+ */
+ private static int getHash(String str) {
+ final int p = 16777619;
+ int hash = (int) 2166136261L;
+ for (int i = 0; i < str.length(); i++)
+ hash = (hash ^ str.charAt(i)) * p;
+ hash += hash << 13;
+ hash ^= hash >> 7;
+ hash += hash << 3;
+ hash ^= hash >> 17;
+ hash += hash << 5;
+ // 如果算出来的值为负数则取其绝对值
+ if (hash < 0)
+ hash = Math.abs(hash);
+ return hash;
+ }
+
+ @Override
+ public String balance(List addressList) {
+ // 如果 addressList 为空或 null，抛出 IllegalArgumentException
+ if (addressList == null || addressList.isEmpty()) {
+ throw new IllegalArgumentException("Address list cannot be null or empty");
+ }
+
+ // 使用UUID作为请求的唯一标识符来进行一致性哈希
+ String random = UUID.randomUUID().toString();
+ return getServer(random, addressList);
+ }
+ public SortedMap getShards() {
+ return shards;
+ }
+
+ public List getRealNodes() {
+ return realNodes;
+ }
+ @Override
+ public String toString() {
+ return "ConsistencyHash";
+ }
+}
+
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/RandomLoadBalance.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/RandomLoadBalance.java
new file mode 100644
index 0000000..583030d
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/RandomLoadBalance.java
@@ -0,0 +1,48 @@
+package com.kama.client.servicecenter.balance.impl;
+
+import com.kama.client.servicecenter.balance.LoadBalance;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+/**
+ * @ClassName RandomLoadBalance
+ * @Description 随机法
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:40
+ * @Version v5.0
+ */
+@Slf4j
+public class RandomLoadBalance implements LoadBalance {
+ // 将Random声明为类级别的字段
+ private final Random random = new Random();
+
+ private final List addressList = new CopyOnWriteArrayList<>();
+
+ @Override
+ public String balance(List addressList) {
+ if (addressList == null || addressList.isEmpty()) {
+ throw new IllegalArgumentException("Address list cannot be null or empty");
+ }
+
+ int choose = random.nextInt(addressList.size());
+ log.info("负载均衡选择了第 {} 号服务器，地址是：{}", choose, addressList.get(choose));
+ return addressList.get(choose); // 返回选择的服务器地址
+ }
+
+ @Override
+ public void addNode(String node) {
+ // 如果是动态添加节点，可以将节点加入到addressList中
+ addressList.add(node);
+ log.info("节点 {} 已加入负载均衡", node);
+ }
+
+ @Override
+ public void delNode(String node) {
+ // 如果是动态删除节点，可以将节点从addressList中移除
+ addressList.remove(node);
+ log.info("节点 {} 已从负载均衡中移除", node);
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/RoundLoadBalance.java b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/RoundLoadBalance.java
new file mode 100644
index 0000000..15398a9
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/client/servicecenter/balance/impl/RoundLoadBalance.java
@@ -0,0 +1,52 @@
+package com.kama.client.servicecenter.balance.impl;
+
+import com.kama.client.servicecenter.balance.LoadBalance;
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * @ClassName RoundLoadBalance
+ * @Description 轮询法
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:41
+ * @Version v5.0
+ */
+@Slf4j
+public class RoundLoadBalance implements LoadBalance {
+
+ // 使用 AtomicInteger 保证线程安全
+ private AtomicInteger choose = new AtomicInteger(0);
+
+ private List addressList = new CopyOnWriteArrayList<>();
+
+ @Override
+ public String balance(List addressList) {
+ if (addressList == null || addressList.isEmpty()) {
+ throw new IllegalArgumentException("Address list cannot be null or empty");
+ }
+
+ // 获取当前索引并更新为下一个
+ int currentChoose = choose.getAndUpdate(i -> (i + 1) % addressList.size());
+
+ String selectedServer = addressList.get(currentChoose);
+ log.info("负载均衡选择了服务器: {}", selectedServer);
+ return selectedServer; // 返回被选择的服务器地址
+ }
+
+ @Override
+ public void addNode(String node) {
+ // 如果是动态添加节点，可以将节点加入到 addressList 中
+ addressList.add(node);
+ log.info("节点 {} 已加入负载均衡", node);
+ }
+
+ @Override
+ public void delNode(String node) {
+ // 如果是动态删除节点，可以将节点从 addressList 中移除
+ addressList.remove(node);
+ log.info("节点 {} 已从负载均衡中移除", node);
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/config/KRpcConfig.java b/version5/krpc-core/src/main/java/com/kama/config/KRpcConfig.java
new file mode 100644
index 0000000..1c53401
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/config/KRpcConfig.java
@@ -0,0 +1,37 @@
+package com.kama.config;
+
+import com.kama.client.servicecenter.balance.impl.ConsistencyHashBalance;
+import com.kama.server.serviceRegister.impl.ZKServiceRegister;
+import common.serializer.myserializer.Serializer;
+import lombok.*;
+
+/**
+ * @ClassName KRpcConfig
+ * @Description 配置文件
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 11:02
+ * @Version v5.0
+ */
+@AllArgsConstructor
+@NoArgsConstructor
+@Getter
+@Setter
+@Builder
+@ToString
+public class KRpcConfig {
+ //名称
+ private String name = "krpc";
+ //端口
+ private Integer port = 9999;
+ //主机名
+ private String host = "localhost";
+ //版本号
+ private String version = "1.0.0";
+ //注册中心
+ private String registry = new ZKServiceRegister().toString();
+ //序列化器
+ private String serializer = Serializer.getSerializerByCode(3).toString();
+ //负载均衡
+ private String loadBalance = new ConsistencyHashBalance().toString();
+
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/config/RpcConstant.java b/version5/krpc-core/src/main/java/com/kama/config/RpcConstant.java
new file mode 100644
index 0000000..6bda0b6
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/config/RpcConstant.java
@@ -0,0 +1,20 @@
+package com.kama.config;
+
+
+/**
+ * @InterfaceName RpcConstants
+ * @Description
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 11:17
+ * @Version v5.0
+ */
+
+public interface RpcConstant {
+
+ //默认的配置文件前缀
+ String CONFIG_FILE_PREFIX = "rpc";
+
+ //默认的服务版本号
+ String DEFAULT_VERSION_DEFAULT = "1.0.0";
+
+}
\ No newline at end of file
diff --git a/version5/krpc-core/src/main/java/com/kama/server/netty/NettyRpcServerHandler.java b/version5/krpc-core/src/main/java/com/kama/server/netty/NettyRpcServerHandler.java
new file mode 100644
index 0000000..0601b82
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/netty/NettyRpcServerHandler.java
@@ -0,0 +1,71 @@
+package com.kama.server.netty;
+
+
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+import io.netty.channel.ChannelFutureListener;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import com.kama.server.provider.ServiceProvider;
+import com.kama.server.ratelimit.RateLimit;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+/**
+ * @ClassName NettyRpcServerHandler
+ * @Description 服务端处理器
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:26
+ * @Version v5.0
+ */
+@AllArgsConstructor // 使用 Lombok 自动生成构造器
+@Slf4j
+public class NettyRpcServerHandler extends SimpleChannelInboundHandler {
+
+ private final ServiceProvider serviceProvider; // 确保通过构造器注入 ServiceProvider
+
+ @Override
+ protected void channelRead0(ChannelHandlerContext ctx, RpcRequest request) throws Exception {
+ if (request == null) {
+ log.error("接收到非法请求，RpcRequest 为空");
+ return;
+ }
+ RpcResponse response = getResponse(request);
+ ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
+ }
+
+ @Override
+ public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+ log.error("处理请求时发生异常: ", cause);
+ ctx.close();
+ }
+
+ private RpcResponse getResponse(RpcRequest rpcRequest) {
+ //得到服务名
+ String interfaceName = rpcRequest.getInterfaceName();
+
+ //接口限流降级
+ RateLimit rateLimit = serviceProvider.getRateLimitProvider().getRateLimit(interfaceName);
+ if (!rateLimit.getToken()) {
+ //如果获取令牌失败，进行限流降级，快速返回结果
+ log.warn("服务限流，接口: {}", interfaceName);
+ return RpcResponse.fail("服务限流，接口 " + interfaceName + " 当前无法处理请求。请稍后再试。");
+ }
+
+ //得到服务端相应服务实现类
+ Object service = serviceProvider.getService(interfaceName);
+ //反射调用方法
+ Method method;
+ try {
+ method = service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType());
+ Object invoke = method.invoke(service, rpcRequest.getParams());
+ return RpcResponse.sussess(invoke);
+ } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+ log.error("方法执行错误，接口: {}, 方法: {}", interfaceName, rpcRequest.getMethodName(), e);
+ return RpcResponse.fail("方法执行错误");
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/netty/NettyServerInitializer.java b/version5/krpc-core/src/main/java/com/kama/server/netty/NettyServerInitializer.java
new file mode 100644
index 0000000..91c8f44
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/netty/NettyServerInitializer.java
@@ -0,0 +1,33 @@
+package com.kama.server.netty;
+
+
+import common.serializer.mycoder.MyDecoder;
+import common.serializer.mycoder.MyEncoder;
+import common.serializer.myserializer.Serializer;
+import io.netty.channel.ChannelInitializer;
+import io.netty.channel.ChannelPipeline;
+import io.netty.channel.socket.SocketChannel;
+import lombok.AllArgsConstructor;
+import com.kama.server.provider.ServiceProvider;
+
+
+/**
+ * @ClassName NettyServerInitializer
+ * @Description 服务端初始化器
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:55
+ * @Version v5.0
+ */
+@AllArgsConstructor
+public class NettyServerInitializer extends ChannelInitializer {
+ private ServiceProvider serviceProvider;
+
+ @Override
+ protected void initChannel(SocketChannel ch) throws Exception {
+ ChannelPipeline pipeline = ch.pipeline();
+ //使用自定义的编/解码器
+ pipeline.addLast(new MyEncoder(Serializer.getSerializerByCode(3)));
+ pipeline.addLast(new MyDecoder());
+ pipeline.addLast(new NettyRpcServerHandler(serviceProvider));
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/provider/ServiceProvider.java b/version5/krpc-core/src/main/java/com/kama/server/provider/ServiceProvider.java
new file mode 100644
index 0000000..4bbde28
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/provider/ServiceProvider.java
@@ -0,0 +1,60 @@
+package com.kama.server.provider;
+
+
+import com.kama.server.ratelimit.provider.RateLimitProvider;
+
+import com.kama.server.serviceRegister.ServiceRegister;
+import com.kama.server.serviceRegister.impl.ZKServiceRegister;
+
+
+import java.net.InetSocketAddress;
+import java.util.HashMap;
+import java.util.Map;
+
+
+/**
+ * @ClassName ServiceProvider
+ * @Description 本地注册中心
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:21
+ * @Version v5.0
+ */
+public class ServiceProvider {
+ private Map interfaceProvider;
+
+ private int port;
+ private String host;
+ //注册服务类
+ private ServiceRegister serviceRegister;
+ //限流器
+ private RateLimitProvider rateLimitProvider;
+
+ public ServiceProvider(String host, int port) {
+ //需要传入服务端自身的网络地址
+ this.host = host;
+ this.port = port;
+ this.interfaceProvider = new HashMap<>();
+ this.serviceRegister = new ZKServiceRegister();
+ this.rateLimitProvider = new RateLimitProvider();
+ }
+
+ public void provideServiceInterface(Object service, boolean canRetry) {
+ String serviceName = service.getClass().getName();
+ Class[] interfaceName = service.getClass().getInterfaces();
+
+ for (Class clazz : interfaceName) {
+ //本机的映射表
+ interfaceProvider.put(clazz.getName(), service);
+ //在注册中心注册服务
+ serviceRegister.register(clazz.getName(), new InetSocketAddress(host, port), canRetry);
+ }
+ }
+
+ public Object getService(String interfaceName) {
+ return interfaceProvider.get(interfaceName);
+ }
+
+ public RateLimitProvider getRateLimitProvider() {
+ return rateLimitProvider;
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/ratelimit/RateLimit.java b/version5/krpc-core/src/main/java/com/kama/server/ratelimit/RateLimit.java
new file mode 100644
index 0000000..02a9998
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/ratelimit/RateLimit.java
@@ -0,0 +1,15 @@
+package com.kama.server.ratelimit;
+
+
+/**
+ * @InterfaceName RateLimit
+ * @Description 限流接口
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:50
+ * @Version v5.0
+ */
+
+public interface RateLimit {
+ //获取访问许可
+ boolean getToken();
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/ratelimit/impl/TokenBucketRateLimitImpl.java b/version5/krpc-core/src/main/java/com/kama/server/ratelimit/impl/TokenBucketRateLimitImpl.java
new file mode 100644
index 0000000..df379d7
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/ratelimit/impl/TokenBucketRateLimitImpl.java
@@ -0,0 +1,60 @@
+package com.kama.server.ratelimit.impl;
+
+import com.kama.server.ratelimit.RateLimit;
+import lombok.extern.slf4j.Slf4j;
+
+
+/**
+ * @ClassName TokenBucketRateLimitImpl
+ * @Description 全局限流
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:53
+ * @Version v5.0
+ */
+
+@Slf4j
+public class TokenBucketRateLimitImpl implements RateLimit {
+
+ // 令牌产生速率（单位：ms）
+ private final int rate;
+ // 桶容量
+ private final int capacity;
+ // 当前桶容量
+ private volatile int curCapacity;
+ // 上次请求时间戳
+ private volatile long lastTimestamp;
+
+ public TokenBucketRateLimitImpl(int rate, int capacity) {
+ this.rate = rate;
+ this.capacity = capacity;
+ this.curCapacity = capacity;
+ this.lastTimestamp = System.currentTimeMillis();
+ }
+
+ @Override
+ public boolean getToken() {
+ // 优化：同步仅限于关键部分，减少锁竞争
+ synchronized (this) {
+ // 如果当前桶还有剩余，就直接返回
+ if (curCapacity > 0) {
+ curCapacity--;
+ return true;
+ }
+
+ long currentTimestamp = System.currentTimeMillis();
+ // 如果距离上一次请求的时间大于 RATE 的时间间隔
+ if (currentTimestamp - lastTimestamp >= rate) {
+ // 计算这段时间内生成的令牌数量
+ int generatedTokens = (int) ((currentTimestamp - lastTimestamp) / rate);
+ if (generatedTokens > 1) {
+ // 只添加剩余令牌，确保不会超过桶的容量
+ curCapacity = Math.min(capacity, curCapacity + generatedTokens - 1);
+ }
+ // 更新时间戳
+ lastTimestamp = currentTimestamp;
+ return true;
+ }
+ return false; // 如果无法获取令牌，返回 false
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/ratelimit/provider/RateLimitProvider.java b/version5/krpc-core/src/main/java/com/kama/server/ratelimit/provider/RateLimitProvider.java
new file mode 100644
index 0000000..9ba551c
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/ratelimit/provider/RateLimitProvider.java
@@ -0,0 +1,34 @@
+package com.kama.server.ratelimit.provider;
+
+import com.kama.server.ratelimit.RateLimit;
+import com.kama.server.ratelimit.impl.TokenBucketRateLimitImpl;
+import lombok.extern.slf4j.Slf4j;
+
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @ClassName RateLimitProvider
+ * @Description 提供限流器
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:54
+ * @Version v5.0
+ */
+@Slf4j
+public class RateLimitProvider {
+ private final Map rateLimitMap = new ConcurrentHashMap<>();
+
+ // 默认的限流桶容量和令牌生成速率
+ private static final int DEFAULT_CAPACITY = 100;
+ private static final int DEFAULT_RATE = 10;
+
+ // 提供限流实例
+ public RateLimit getRateLimit(String interfaceName) {
+ return rateLimitMap.computeIfAbsent(interfaceName, key -> {
+ RateLimit rateLimit = new TokenBucketRateLimitImpl(DEFAULT_CAPACITY, DEFAULT_RATE);
+ log.info("为接口 [{}] 创建了新的限流策略: {}", interfaceName, rateLimit);
+ return rateLimit;
+ });
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/server/RpcServer.java b/version5/krpc-core/src/main/java/com/kama/server/server/RpcServer.java
new file mode 100644
index 0000000..beb6bb0
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/server/RpcServer.java
@@ -0,0 +1,16 @@
+package com.kama.server.server;
+
+
+/**
+ * @InterfaceName RpcServer
+ * @Description 服务端接口
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:21
+ * @Version v1.0
+ */
+
+public interface RpcServer {
+ void start(int port);
+
+ void stop();
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/server/impl/NettyRpcServer.java b/version5/krpc-core/src/main/java/com/kama/server/server/impl/NettyRpcServer.java
new file mode 100644
index 0000000..ebab364
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/server/impl/NettyRpcServer.java
@@ -0,0 +1,81 @@
+package com.kama.server.server.impl;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.kama.server.netty.NettyServerInitializer;
+import com.kama.server.provider.ServiceProvider;
+import com.kama.server.server.RpcServer;
+
+/**
+ * @ClassName NettyRpcServer
+ * @Description Netty服务端
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:25
+ * @Version v5.0
+ */
+@Slf4j
+@AllArgsConstructor
+public class NettyRpcServer implements RpcServer {
+ private final ServiceProvider serviceProvider; // 只需要 ServiceProvider
+ private ChannelFuture channelFuture; // ChannelFuture 在 start 方法内初始化
+ public NettyRpcServer(ServiceProvider serviceProvider) {
+ this.serviceProvider = serviceProvider;
+ }
+
+ @Override
+ public void start(int port) {
+ NioEventLoopGroup bossGroup = new NioEventLoopGroup();
+ NioEventLoopGroup workGroup = new NioEventLoopGroup();
+ log.info("Netty服务端启动了");
+
+ try {
+ ServerBootstrap serverBootstrap = new ServerBootstrap();
+ serverBootstrap.group(bossGroup, workGroup)
+ .channel(NioServerSocketChannel.class)
+ .childHandler(new NettyServerInitializer(serviceProvider));
+
+ // 同步阻塞，绑定端口启动服务
+ channelFuture = serverBootstrap.bind(port).sync();
+ log.info("Netty服务端已绑定端口：{}", port);
+
+ // 阻塞，等待服务关闭
+ channelFuture.channel().closeFuture().sync();
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("Netty服务端启动中断：{}", e.getMessage(), e);
+ } finally {
+ shutdown(bossGroup, workGroup); // 集中管理线程组资源
+ log.info("Netty服务端关闭了");
+ }
+ }
+
+ @Override
+ public void stop() {
+ if (channelFuture != null) {
+ try {
+ channelFuture.channel().close().sync();
+ log.info("Netty服务端主通道已关闭");
+ } catch (InterruptedException e) {
+ Thread.currentThread().interrupt();
+ log.error("关闭Netty服务端主通道时中断：{}", e.getMessage(), e);
+ }
+ } else {
+ log.warn("Netty服务端主通道尚未启动，无法关闭");
+ }
+ }
+
+ private void shutdown(NioEventLoopGroup bossGroup, NioEventLoopGroup workGroup) {
+ if (bossGroup != null) {
+ bossGroup.shutdownGracefully().syncUninterruptibly();
+ }
+ if (workGroup != null) {
+ workGroup.shutdownGracefully().syncUninterruptibly();
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/server/impl/SimpleRpcServer.java b/version5/krpc-core/src/main/java/com/kama/server/server/impl/SimpleRpcServer.java
new file mode 100644
index 0000000..792c4ec
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/server/impl/SimpleRpcServer.java
@@ -0,0 +1,70 @@
+package com.kama.server.server.impl;
+
+import lombok.AllArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.kama.server.provider.ServiceProvider;
+import com.kama.server.server.RpcServer;
+import com.kama.server.server.work.WorkThread;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * @ClassName SimpleRpcServer
+ * @Description 简单服务端
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:23
+ * @Version v5.0
+ */
+@AllArgsConstructor
+@Slf4j
+public class SimpleRpcServer implements RpcServer {
+ private ServiceProvider serviceProvider;
+ // 控制服务器运行状态
+ private AtomicBoolean running = new AtomicBoolean(true);
+ private ServerSocket serverSocket;
+
+ @Override
+ public void start(int port) {
+ try {
+ serverSocket = new ServerSocket(port);
+ log.info("服务器启动了，监听端口：{}", port);
+ while (running.get()) {
+ try {
+ Socket socket = serverSocket.accept();
+ new Thread(new WorkThread(socket, serviceProvider)).start();
+ } catch (IOException e) {
+ if (running.get()) { // 如果不是因为服务器被停止导致的异常
+ log.error("接受连接时发生异常：{}", e.getMessage(), e);
+ }
+ }
+ }
+ } catch (IOException e) {
+ log.error("服务器启动失败：{}", e.getMessage(), e);
+ } finally {
+ stop();
+ }
+ }
+
+ @Override
+ public void stop() {
+ if (!running.get()) return; // 防止重复停止
+
+ running.set(false);
+ log.info("服务器正在关闭...");
+
+ // 关闭 ServerSocket
+ if (serverSocket != null && !serverSocket.isClosed()) {
+ try {
+ serverSocket.close();
+ log.info("服务器已关闭");
+ } catch (IOException e) {
+ log.error("关闭服务器时发生异常：{}", e.getMessage(), e);
+ }
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/server/work/WorkThread.java b/version5/krpc-core/src/main/java/com/kama/server/server/work/WorkThread.java
new file mode 100644
index 0000000..447a600
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/server/work/WorkThread.java
@@ -0,0 +1,61 @@
+package com.kama.server.server.work;
+
+
+import common.message.RpcRequest;
+import common.message.RpcResponse;
+import lombok.AllArgsConstructor;
+import com.kama.server.provider.ServiceProvider;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.net.Socket;
+
+/**
+ * @ClassName WorkThread
+ * @Description
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:22
+ * @Version v5.0
+ */
+@AllArgsConstructor
+public class WorkThread implements Runnable {
+ private Socket socket;
+ private ServiceProvider serviceProvide;
+
+ @Override
+ public void run() {
+ try {
+ ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
+ ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
+ //读取客户端传过来的request
+ RpcRequest rpcRequest = (RpcRequest) ois.readObject();
+ //反射调用服务方法获取返回值
+ RpcResponse rpcResponse = getResponse(rpcRequest);
+ //向客户端写入response
+ oos.writeObject(rpcResponse);
+ oos.flush();
+ } catch (IOException | ClassNotFoundException e) {
+ e.printStackTrace();
+ }
+ }
+
+ private RpcResponse getResponse(RpcRequest rpcRequest) {
+ //得到服务名
+ String interfaceName = rpcRequest.getInterfaceName();
+ //得到服务端相应服务实现类
+ Object service = serviceProvide.getService(interfaceName);
+ //反射调用方法
+ Method method;
+ try {
+ method = service.getClass().getMethod(rpcRequest.getMethodName(), rpcRequest.getParamsType());
+ Object invoke = method.invoke(service, rpcRequest.getParams());
+ return RpcResponse.sussess(invoke);
+ } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+ e.printStackTrace();
+ return RpcResponse.fail("方法执行错误");
+ }
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/serviceRegister/ServiceRegister.java b/version5/krpc-core/src/main/java/com/kama/server/serviceRegister/ServiceRegister.java
new file mode 100644
index 0000000..dd0398d
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/serviceRegister/ServiceRegister.java
@@ -0,0 +1,16 @@
+package com.kama.server.serviceRegister;
+
+
+import java.net.InetSocketAddress;
+
+/**
+ * @InterfaceName ServiceRegister
+ * @Description 服务注册接口
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:27
+ * @Version v5.0
+ */
+
+public interface ServiceRegister {
+ void register(String serviceName, InetSocketAddress serviceAddress, boolean canRetry);
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/server/serviceRegister/impl/ZKServiceRegister.java b/version5/krpc-core/src/main/java/com/kama/server/serviceRegister/impl/ZKServiceRegister.java
new file mode 100644
index 0000000..ce952e6
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/server/serviceRegister/impl/ZKServiceRegister.java
@@ -0,0 +1,74 @@
+package com.kama.server.serviceRegister.impl;
+
+import lombok.extern.slf4j.Slf4j;
+import org.apache.curator.RetryPolicy;
+import org.apache.curator.framework.CuratorFramework;
+import org.apache.curator.framework.CuratorFrameworkFactory;
+import org.apache.curator.retry.ExponentialBackoffRetry;
+import org.apache.zookeeper.CreateMode;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import com.kama.server.serviceRegister.ServiceRegister;
+
+import java.net.InetSocketAddress;
+
+/**
+ * @ClassName ZKServiceRegister
+ * @Description zk服务注册中心
+ * @Author Tong
+ * @LastChangeDate 2024-12-02 10:28
+ * @Version v5.0
+ */
+@Slf4j
+public class ZKServiceRegister implements ServiceRegister {
+ private CuratorFramework client;
+ private static final String ROOT_PATH = "MyRPC";
+ private static final String RETRY = "CanRetry";
+
+ public ZKServiceRegister() {
+ RetryPolicy policy = new ExponentialBackoffRetry(1000, 3);
+ this.client = CuratorFrameworkFactory.builder()
+ .connectString("127.0.0.1:2181")
+ .sessionTimeoutMs(40000)
+ .retryPolicy(policy)
+ .namespace(ROOT_PATH)
+ .build();
+ this.client.start();
+ log.info("Zookeeper 连接成功");
+ }
+
+ @Override
+ public void register(String serviceName, InetSocketAddress serviceAddress, boolean canRetry) {
+ try {
+ if (client.checkExists().forPath("/" + serviceName) == null) {
+ client.create().creatingParentsIfNeeded().withMode(CreateMode.PERSISTENT).forPath("/" + serviceName);
+ log.info("服务节点 {} 创建成功", "/" + serviceName);
+ }
+
+ String path = "/" + serviceName + "/" + getServiceAddress(serviceAddress);
+ if (client.checkExists().forPath(path) == null) {
+ client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(path);
+ log.info("服务地址 {} 注册成功", path);
+ } else {
+ log.info("服务地址 {} 已经存在，跳过注册", path);
+ }
+
+ if (canRetry) {
+ path = "/" + RETRY + "/" + serviceName;
+ client.create().creatingParentsIfNeeded().withMode(CreateMode.EPHEMERAL).forPath(path);
+ log.info("重试标识 {} 注册成功", path);
+ }
+ } catch (Exception e) {
+ log.error("服务注册失败，服务名：{}，错误信息：{}", serviceName, e.getMessage(), e);
+ }
+ }
+
+ @Override
+ public String toString() {
+ return "zookeeper";
+ }
+
+ private String getServiceAddress(InetSocketAddress serverAddress) {
+ return serverAddress.getHostName() + ":" + serverAddress.getPort();
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/test/balance/ConsistencyHashBalanceTest.java b/version5/krpc-core/src/main/java/com/kama/test/balance/ConsistencyHashBalanceTest.java
new file mode 100644
index 0000000..fa94dc6
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/test/balance/ConsistencyHashBalanceTest.java
@@ -0,0 +1,100 @@
+package com.kama.test.balance;
+
+import com.kama.client.servicecenter.balance.impl.ConsistencyHashBalance;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+/**
+ * @ClassName ConsistencyHashBalanceTest
+ * @Description 一致性哈希测试类
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 15:39
+ * @Version v5.0
+ */
+public class ConsistencyHashBalanceTest {
+
+ private ConsistencyHashBalance balance;
+
+ @Before
+ public void setUp() {
+ balance = new ConsistencyHashBalance();
+ }
+
+ @Test
+ public void testInit() {
+ // 模拟真实节点
+ List nodes = Arrays.asList("server1", "server2", "server3");
+ balance.init(nodes);
+
+ // 验证虚拟节点的初始化是否正确
+ assertTrue("shards should not be empty", balance.getShards().size() > 0);
+ assertTrue("realNodes should contain all nodes", balance.getRealNodes().containsAll(nodes));
+ }
+
+ @Test
+ public void testGetServer() {
+ // 模拟真实节点
+ List nodes = Arrays.asList("server1", "server2", "server3");
+ balance.init(nodes);
+
+ // 使用 UUID 作为请求的唯一标识符进行负载均衡
+ String server = balance.getServer("request-1", nodes);
+ assertNotNull("Server should not be null", server);
+ assertTrue("Server should be one of the real nodes", nodes.contains(server));
+
+ // 确保多个请求的分配在不同节点上（可根据测试的多次运行结果观察）
+ String server2 = balance.getServer("request-2", nodes);
+ assertNotEquals("Server should be different from the previous request", server, server2);
+ }
+
+ @Test
+ public void testAddNode() {
+ // 模拟真实节点
+ List nodes = Arrays.asList("server1", "server2");
+ balance.init(nodes);
+
+ // 新加入一个节点
+ balance.addNode("server3");
+
+ // 验证新节点是否被加入
+ assertTrue("server3 should be added", balance.getRealNodes().contains("server3"));
+ assertTrue("shards should contain virtual nodes for server3", balance.getShards().size() > 0);
+ }
+
+ @Test
+ public void testDelNode() {
+ // 模拟真实节点
+ List nodes = Arrays.asList("server1", "server2");
+ balance.init(nodes);
+
+ // 删除一个节点
+ balance.delNode("server1");
+
+ // 验证该节点是否被移除
+ assertFalse("server1 should be removed", balance.getRealNodes().contains("server1"));
+ assertFalse("shards should not contain virtual nodes for server1", balance.getShards().values().stream().anyMatch(vn -> vn.startsWith("server1")));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testBalanceWithEmptyList() {
+ // 测试地址列表为空时，抛出 IllegalArgumentException
+ balance.balance(Arrays.asList());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testBalanceWithNullList() {
+ // 测试地址列表为 null 时，抛出 IllegalArgumentException
+ balance.balance(null);
+ }
+
+ @Test
+ public void testGetVirtualNum() {
+ // 测试虚拟节点的数量
+ assertEquals("Virtual nodes count should be 5", 5, ConsistencyHashBalance.getVirtualNum());
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/test/balance/RandomLoadBalanceTest.java b/version5/krpc-core/src/main/java/com/kama/test/balance/RandomLoadBalanceTest.java
new file mode 100644
index 0000000..4f1aa33
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/test/balance/RandomLoadBalanceTest.java
@@ -0,0 +1,76 @@
+package com.kama.test.balance;
+
+import com.kama.client.servicecenter.balance.impl.RandomLoadBalance;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * @ClassName RandomLoadBalanceTest
+ * @Description 随机负载均衡器测试
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 15:43
+ * @Version v5.0
+ */
+public class RandomLoadBalanceTest {
+
+ private RandomLoadBalance loadBalance;
+
+ @Before
+ public void setUp() {
+ // 在每个测试前初始化负载均衡器
+ loadBalance = new RandomLoadBalance();
+ }
+
+ @Test
+ public void testBalance_WithNonEmptyList() {
+ // 准备一个非空的地址列表
+ List addressList = Arrays.asList("server1", "server2", "server3");
+
+ // 使用 balance 方法选择一个服务器
+ String selectedServer = loadBalance.balance(addressList);
+
+ // 确保选择的服务器在列表中
+ assertTrue(addressList.contains(selectedServer));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testBalance_WithEmptyList() {
+ // 测试空的节点列表，应该抛出 IllegalArgumentException 异常
+ loadBalance.balance(Arrays.asList());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testBalance_WithNullList() {
+ // 测试 null 的节点列表，应该抛出 IllegalArgumentException 异常
+ loadBalance.balance(null);
+ }
+
+ @Test
+ public void testAddNode() {
+ // 测试添加节点到负载均衡器
+ loadBalance.addNode("server4");
+
+ // 确保新添加的节点在负载均衡器中
+ List addressList = Arrays.asList("server1", "server2", "server3", "server4");
+ String selectedServer = loadBalance.balance(addressList);
+ assertTrue(addressList.contains(selectedServer));
+ }
+
+ @Test
+ public void testDelNode() {
+ // 测试从负载均衡器中移除节点
+ loadBalance.addNode("server4");
+ loadBalance.delNode("server4");
+
+ // 确保删除后的节点不再在负载均衡器中
+ List addressList = Arrays.asList("server1", "server2", "server3");
+ String selectedServer = loadBalance.balance(addressList);
+ assertFalse(addressList.contains("server4"));
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/test/balance/RoundLoadBalanceTest.java b/version5/krpc-core/src/main/java/com/kama/test/balance/RoundLoadBalanceTest.java
new file mode 100644
index 0000000..796a60f
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/test/balance/RoundLoadBalanceTest.java
@@ -0,0 +1,93 @@
+package com.kama.test.balance;
+
+import com.kama.client.servicecenter.balance.impl.RoundLoadBalance;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+/**
+ * @ClassName RoundLoadBalanceTest
+ * @Description 轮询测试类
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 15:46
+ * @Version v5.0
+ */
+public class RoundLoadBalanceTest {
+
+ private RoundLoadBalance loadBalance;
+
+ @Before
+ public void setUp() {
+ // 在每个测试前初始化负载均衡器
+ loadBalance = new RoundLoadBalance();
+ }
+
+ @Test
+ public void testBalance_WithNonEmptyList() {
+ // 准备一个非空的地址列表
+ List addressList = Arrays.asList("server1", "server2", "server3");
+
+ // 执行 balance 方法并获取返回的服务器
+ String selectedServer = loadBalance.balance(addressList);
+
+ // 确保选择的服务器在列表中
+ assertTrue(addressList.contains(selectedServer));
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testBalance_WithEmptyList() {
+ // 测试空的节点列表，应该抛出 IllegalArgumentException 异常
+ loadBalance.balance(Arrays.asList());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void testBalance_WithNullList() {
+ // 测试 null 的节点列表，应该抛出 IllegalArgumentException 异常
+ loadBalance.balance(null);
+ }
+
+ @Test
+ public void testAddNode() {
+ // 测试添加节点到负载均衡器
+ loadBalance.addNode("server4");
+
+ // 确保新添加的节点在负载均衡器中
+ List addressList = Arrays.asList("server1", "server2", "server3", "server4");
+ String selectedServer = loadBalance.balance(addressList);
+ assertTrue(addressList.contains(selectedServer));
+ }
+
+ @Test
+ public void testDelNode() {
+ // 测试从负载均衡器中移除节点
+ loadBalance.addNode("server4");
+ loadBalance.delNode("server4");
+
+ // 确保删除后的节点不再在负载均衡器中
+ List addressList = Arrays.asList("server1", "server2", "server3");
+ String selectedServer = loadBalance.balance(addressList);
+ assertFalse(addressList.contains("server4"));
+ }
+
+ @Test
+ public void testBalance_RoundRobin() {
+ // 测试负载均衡是否按轮询顺序选择服务器
+ List addressList = Arrays.asList("server1", "server2", "server3");
+
+ // 轮询选择服务器
+ String firstSelection = loadBalance.balance(addressList);
+ String secondSelection = loadBalance.balance(addressList);
+ String thirdSelection = loadBalance.balance(addressList);
+ String fourthSelection = loadBalance.balance(addressList); // Should loop back to first
+
+ // 确保选择的服务器是轮询顺序的
+ assertNotEquals(firstSelection, secondSelection);
+ assertNotEquals(secondSelection, thirdSelection);
+ assertNotEquals(thirdSelection, fourthSelection);
+ assertEquals(firstSelection, fourthSelection); // Should be back to the first
+ }
+}
diff --git a/version5/krpc-core/src/main/java/com/kama/test/serializer/HessianSerializerTest.java b/version5/krpc-core/src/main/java/com/kama/test/serializer/HessianSerializerTest.java
new file mode 100644
index 0000000..46c2854
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/test/serializer/HessianSerializerTest.java
@@ -0,0 +1,52 @@
+package com.kama.test.serializer;
+
+
+import common.exception.SerializeException;
+import common.serializer.myserializer.HessianSerializer;
+import org.junit.Test;
+
+/**
+ * @ClassName HessianSerializerTest
+ * @Description Hessian测试类
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 15:21
+ * @Version v5.0
+ */
+import org.junit.Test;
+import static org.junit.Assert.*;
+
+public class HessianSerializerTest {
+
+ private HessianSerializer serializer = new HessianSerializer();
+
+ @Test
+ public void testSerializeAndDeserialize() {
+ // 创建一个测试对象
+ String original = "Hello, Hessian!";
+
+ // 序列化
+ byte[] serialized = serializer.serialize(original);
+ assertNotNull("序列化结果不应为 null", serialized);
+
+ // 反序列化
+ Object deserialized = serializer.deserialize(serialized, 3);
+ assertNotNull("反序列化结果不应为 null", deserialized);
+
+ // 校验反序列化的结果
+ assertEquals("反序列化的对象应该与原对象相同", original, deserialized);
+ }
+
+ @Test
+ public void testDeserializeWithInvalidData() {
+ byte[] invalidData = new byte[]{1, 2, 3}; // 假数据
+
+ // 测试无效数据反序列化
+ try {
+ serializer.deserialize(invalidData, 3);
+ fail("反序列化时应抛出异常");
+ } catch (SerializeException e) {
+ assertEquals("Deserialization failed", e.getMessage());
+ }
+ }
+}
+
diff --git a/version5/krpc-core/src/main/java/com/kama/test/serializer/KryoSerializerTest.java b/version5/krpc-core/src/main/java/com/kama/test/serializer/KryoSerializerTest.java
new file mode 100644
index 0000000..b8532ae
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/test/serializer/KryoSerializerTest.java
@@ -0,0 +1,89 @@
+package com.kama.test.serializer;
+
+
+import com.kama.pojo.User;
+import common.exception.SerializeException;
+import common.serializer.myserializer.KryoSerializer;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * @ClassName KryoSerializer
+ * @Description kryo测试类
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 15:31
+ * @Version v5.0
+ */
+public class KryoSerializerTest {
+
+ private KryoSerializer serializer = new KryoSerializer();
+
+ @Test
+ public void testSerializeAndDeserialize() {
+ // 创建一个 User 对象
+ User originalUser = User.builder()
+ .id(1)
+ .userName("TestUser")
+ .gender(true)
+ .build();
+
+ // 序列化
+ byte[] serialized = serializer.serialize(originalUser);
+ assertNotNull("序列化结果不应为 null", serialized);
+
+ // 反序列化
+ Object deserialized = serializer.deserialize(serialized, 1);
+ assertNotNull("反序列化结果不应为 null", deserialized);
+
+ // 校验反序列化的对象是否与原对象相同
+ assertTrue("反序列化的对象应该是 User 类型", deserialized instanceof User);
+ User deserializedUser = (User) deserialized;
+ assertEquals("反序列化的 User 应该与原 User 相同", originalUser, deserializedUser);
+ }
+
+ @Test
+ public void testSerializeNullObject() {
+ // 测试序列化 null 对象
+ try {
+ serializer.serialize(null);
+ fail("序列化 null 对象时应抛出 IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ assertEquals("Cannot serialize null object", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDeserializeNullBytes() {
+ // 测试反序列化 null 或空字节数组
+ try {
+ serializer.deserialize(null, 1);
+ fail("反序列化 null 字节数组时应抛出 IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ assertEquals("Cannot deserialize null or empty byte array", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDeserializeEmptyBytes() {
+ // 测试反序列化空字节数组
+ try {
+ serializer.deserialize(new byte[0], 1);
+ fail("反序列化空字节数组时应抛出 IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ assertEquals("Cannot deserialize null or empty byte array", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDeserializeInvalidMessageType() {
+ // 测试反序列化未知的 messageType
+ byte[] serialized = serializer.serialize(new User(1, "TestUser", true));
+ try {
+ serializer.deserialize(serialized, 99); // 使用无效的 messageType
+ fail("反序列化时应抛出 SerializeException");
+ } catch (SerializeException e) {
+ assertEquals("Deserialization failed", e.getMessage());
+ }
+ }
+}
\ No newline at end of file
diff --git a/version5/krpc-core/src/main/java/com/kama/test/serializer/ProtostuffSerializerTest.java b/version5/krpc-core/src/main/java/com/kama/test/serializer/ProtostuffSerializerTest.java
new file mode 100644
index 0000000..ed9fce5
--- /dev/null
+++ b/version5/krpc-core/src/main/java/com/kama/test/serializer/ProtostuffSerializerTest.java
@@ -0,0 +1,89 @@
+package com.kama.test.serializer;
+
+
+import com.kama.pojo.User;
+import common.exception.SerializeException;
+import common.serializer.myserializer.ProtostuffSerializer;
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+/**
+ * @ClassName ProtostuffSerializerTest
+ * @Description protostuff 序列化测试
+ * @Author Tong
+ * @LastChangeDate 2024-12-05 15:32
+ * @Version v5.0
+ */
+public class ProtostuffSerializerTest {
+
+ private ProtostuffSerializer serializer = new ProtostuffSerializer();
+
+ @Test
+ public void testSerializeAndDeserialize() {
+ // 创建一个 User 对象
+ User originalUser = User.builder()
+ .id(1)
+ .userName("TestUser")
+ .gender(true)
+ .build();
+
+ // 序列化
+ byte[] serialized = serializer.serialize(originalUser);
+ assertNotNull("序列化结果不应为 null", serialized);
+
+ // 反序列化
+ Object deserialized = serializer.deserialize(serialized, 1);
+ assertNotNull("反序列化结果不应为 null", deserialized);
+
+ // 校验反序列化的对象是否与原对象相同
+ assertTrue("反序列化的对象应该是 User 类型", deserialized instanceof User);
+ User deserializedUser = (User) deserialized;
+ assertEquals("反序列化的 User 应该与原 User 相同", originalUser, deserializedUser);
+ }
+
+ @Test
+ public void testSerializeNullObject() {
+ // 测试序列化 null 对象
+ try {
+ serializer.serialize(null);
+ fail("序列化 null 对象时应抛出 IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ assertEquals("Cannot serialize null object", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDeserializeNullBytes() {
+ // 测试反序列化 null 字节数组
+ try {
+ serializer.deserialize(null, 1);
+ fail("反序列化 null 字节数组时应抛出 IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ assertEquals("Cannot deserialize null or empty byte array", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDeserializeEmptyBytes() {
+ // 测试反序列化空字节数组
+ try {
+ serializer.deserialize(new byte[0], 1);
+ fail("反序列化空字节数组时应抛出 IllegalArgumentException");
+ } catch (IllegalArgumentException e) {
+ assertEquals("Cannot deserialize null or empty byte array", e.getMessage());
+ }
+ }
+
+ @Test
+ public void testDeserializeInvalidMessageType() {
+ // 测试反序列化未知的 messageType
+ byte[] serialized = serializer.serialize(new User(1, "TestUser", true));
+ try {
+ serializer.deserialize(serialized, 99); // 使用无效的 messageType
+ fail("反序列化时应抛出 SerializeException");
+ } catch (SerializeException e) {
+ assertEquals("Unknown message type: 99", e.getMessage());
+ }
+ }
+}
\ No newline at end of file
diff --git a/version5/krpc-core/src/main/resources/META-INF/serializer/com.kama.common.serializer.myserializer.Serializer b/version5/krpc-core/src/main/resources/META-INF/serializer/com.kama.common.serializer.myserializer.Serializer
new file mode 100644
index 0000000..90c3187
--- /dev/null
+++ b/version5/krpc-core/src/main/resources/META-INF/serializer/com.kama.common.serializer.myserializer.Serializer
@@ -0,0 +1,5 @@
+Hessian=com.kama.common.serializer.myserializer.HessianSerializer
+protobuf=com.kama.common.serializer.myserializer.ProtobufSerializer
+json=com.kama.common.serializer.myserializer.JsonSerializer
+kryo=com.kama.common.serializer.myserializer.KryoSerializer
+jdk=com.kama.common.serializer.myserializer.ObjectSerializer
diff --git a/version5/krpc-core/target/classes/META-INF/serializer/com.kama.common.serializer.myserializer.Serializer b/version5/krpc-core/target/classes/META-INF/serializer/com.kama.common.serializer.myserializer.Serializer
new file mode 100644
index 0000000..90c3187
--- /dev/null
+++ b/version5/krpc-core/target/classes/META-INF/serializer/com.kama.common.serializer.myserializer.Serializer
@@ -0,0 +1,5 @@
+Hessian=com.kama.common.serializer.myserializer.HessianSerializer
+protobuf=com.kama.common.serializer.myserializer.ProtobufSerializer
+json=com.kama.common.serializer.myserializer.JsonSerializer
+kryo=com.kama.common.serializer.myserializer.KryoSerializer
+jdk=com.kama.common.serializer.myserializer.ObjectSerializer
diff --git a/version5/krpc-core/target/classes/com/kama/KRpcApplication.class b/version5/krpc-core/target/classes/com/kama/KRpcApplication.class
new file mode 100644
index 0000000000000000000000000000000000000000..0ec83d5467882dc1d049ad9d87dff4d8cf84de75
GIT binary patch
literal 1617
zcmaJ>-E$LF6#w0%WH;%Srb|CazeroKNr0|Y6g35fKouHvY{if9
zQDqQjcyJhB{F*`Q6GOp)YOOf(;0%8UY0H!E4&!+4Zb;U2^kw(nbI<*q-}#+$?xVkd
z{uRJMFIS&@
zd~JR8R`Ou-!;f0gi7pA<3VN`evTDX*Xfdogn_)DSZ)7~}I)+uu1}we?+4PKrUWVTP
zW-pQlcAgLlx#~|a1B%Qm3W($3^CK@=Y0di
zfgsJC$t#s0%Np*|$nHda@Ck=AZ}`grADT{C}My?$+d@wTU*
zgcQTJhBC+A(+g!$*BBBA%h*lI`A9x$_2$yXkKYmA6L?ggVlEz_XhG$F*VU0_JU(y^7+dXx>+0X*tEUi=!Ho`b|j?7Qk7DfYSD|rB2XhAp8=n3G(aoD3H@Sc(Rp1cL=aW$b1EMv!SNK6UX
zUFv{`yNK@m3KHk;BkkEK+MW
z`P|g+-ZHX`{h5c0kn@>`yC0D0Hu<%Z4hiy35Hs=j)$Sz)K+GdZkw=+MV!XP5lEMSdvEo
literal 0
HcmV?d00001
diff --git a/version5/krpc-core/target/classes/com/kama/client/cache/ServiceCache.class b/version5/krpc-core/target/classes/com/kama/client/cache/ServiceCache.class
new file mode 100644
index 0000000000000000000000000000000000000000..84cacfec6ce39ddd148f83a722a6550eeeaba5c1
GIT binary patch
literal 3168
zcmb_f+jA3D82_ClZPH{*X@SOar<6A7g@AG?q!vn`+)Aki0tKpW(_32
z3^3Gj^Z~&-0}c-8$V>s9-VlBA!9T-k0zUcTn~vjmb~owv!oY*mna$aA{awEAJKNv>
zop=o3Reb1#1y(z30`id0u&_t$6Ma!J9`POS?2*DrhWrLOE+-oqtR8Qu01gz`;S}J4
zz)&7mV!ktCO!S4LvJ_AH!eY2v@&zTePYz1~{=$%_butvSXq%^!a@2Q7?De~_07Z5z
z6i|#3hQb-646d*ePl|FpaZu`KSmM!Fo1pop`m5$rJ>
z(z1}-O=;-HK>;mXNk=y49B5_mzd!^}O@1;fcGH(`{&D>_-?dG^Yj~Z(E+_VI2oy>l
zJ!g+_=Sm$2F>KB%l5;Do;lz_~CwLl-KA=N#sgW7Gpl!bv$GM3C2Tm|-)elYIzW?-x
zZ}=K5*9Hb(#HCYQ{3<8jz?*iwB|tZSGpsWk6^M$7gx@>2
zMA*?qb!plh(m0$_RbDOwx#m7G(M?6si7>2mNKlT%#bipQ^0`;HK3g^$Op!1n;d748
zGo#Vp=%?@sC|$H+QHvaxT2rx3Nj)NVMyZGDT3C#RL{;YRMyD;=EmQPVv^>AY)855Y
zFpaW*L@^5gbK=-Q@1-Dc(P~vnBzQnlxic}=LX;*X^ed&63M$8|sj1xs#x4|P#vTl%
zGwJmAW+_$7+IU{2=q3s##qb$&!%$+0D)mOiuw?LS(y>0b_|9<0jFmHXD$%aoM$Wi&
zF8AW505eYFi3
z#~xsL$?6(Q!s)+{ZV?e-ilwk$YTuImA
zDr~@N)YIEel;a@P?qgV|VctY|%Lu=MURY_yDx*bM4IaF87OKYWI1<#dAW3JG(yzWU
zm0QVMeHs?ahDus-4sRO@{7y>c(MZUoz)rIQ+ihhwqP>wcD6Vo6gVkK#cxKi6{Nlm{E)BMZHR=`XAtI60JVp>aob!f(V>?aeCVq=c?QX1jB
zxig_0+fa^e2>lvcKKc%|tQv3bvc57!D>>VISpLR-7xfR|T~dWRewJqQ@bcvN-arY5
z+(?LbS}}&*BWC&|G}o#*Sfb(COboWrWmHdIZr2cVy=lK3PLF|;Bd~%kGvaoTV7!+L
zybNu|>2;XTYOVVfyLiAI;Bi>bTU>UI?vN2sWWZrI9i%~H_$YxtmQ%l-tAEn0ekBU%
zupKC*I9rA$Qhyg|9v~LGskH}fbmgDI0gX?!4lKu~Bd2?Z5oLumUyn;3Z(Mi1CmUr2
zu>6BIJKQcZ{e4rWa-o1lC5|z4JjC)zgei%nhp_WFVVcVP9|)R43*FRnp4t|C@E-s>
Bk39eY
literal 0
HcmV?d00001
diff --git a/version5/krpc-core/target/classes/com/kama/client/circuitbreaker/CircuitBreaker$1.class b/version5/krpc-core/target/classes/com/kama/client/circuitbreaker/CircuitBreaker$1.class
new file mode 100644
index 0000000000000000000000000000000000000000..9651ad6680772b58a7dc9cd7eb76a0bbfd55726a
GIT binary patch
literal 889
zcmbVK+iuf95Ix(Zb`o6bUZA1eN--rV7mEti2PhJRM2*M=$yIsi1KMm>%{GpW)=v2Y
zeuZa1LI|OL03U^zbtiShcFxTF`u*bszz*)0FoT?pyn|U-3|k@|`9nV9
zz6h0!QeP-7#wzV;$%j(=wF!JVfkDbs$zUDxa4Zvs?Mn5aHGPDqMHEo9QF3qr4ud~c
z2=5WYju(7TsTj2RdykwwqrjUe@Xjmn{;6Q*pjo6sTy!uGmm%MMQ|~Z5{vR!-poMv>IDkSB>u+%+1D>olg!Et|nGJ7R8PjqEK#ACaRSu>BqE@Vh<`-X*l_Y?B3Gq^%<_6)8Pv@-aa+>2Po3NE3H+t?s`7h8BjHivZzY-Qm$=?v5b
mz@vWw)?1rywEr&1<4$&AgWN%=LhEM6RB(@MDa)HSZs8AP>EE9K
literal 0
HcmV?d00001
diff --git a/version5/krpc-core/target/classes/com/kama/client/circuitbreaker/CircuitBreaker.class b/version5/krpc-core/target/classes/com/kama/client/circuitbreaker/CircuitBreaker.class
new file mode 100644
index 0000000000000000000000000000000000000000..6d1b74adb386cbdb006efcaa366fdde6aa1fdf4f
GIT binary patch
literal 3249
zcmb7G?N=1{6@G?Y++`gEK_yB{#G-+XvWYP!4a5W&Fjx=;g3-J=3<1(
zLqH9QNi>PcX+5bLJvnN82?z#FKlkr&7x?5Kke;4CcV@)Zq&elo%>BL1eR=NlyLbNe
zpPRPky{$!JTD&*X+O^lvZ3PQz&A4fAQsAqs>dZqBc>#n}
zEQG3Hy`C6|^lJlJM30$9+>Yp`rKe20%QCcn!-_=R>1KD@Zfmwdh0*5L_J(=|8=B|;
zc}*S`p&)=l6^q4#b@Ni8AU7#a1W>G?%84~)o3V(Vi0diKk_a?AF<|PEI!83cZKKz)
zLMXygL1>u*e`S-vun3Q+SdJA6)E>=@r7Rpmmi?wW3M(xcSNnQ9dg$B1Rv)&Wt!-LT9=cL+~neE?6X
z*np=W;7j{~q-_i+SnMGw-?W&qn3;5_2qsWrf+@9S^DhNneWeKE`FUkdFAfZmj@3mB!f2v
z@PdjLQAcMUR>y3a@t%Z&$12^dIK*zZEi>L*leOYfy+-mHMSTDbDjKmx0eLYGdRIKD
z;Q5O7{idz=wP^b)_;H2YjSBZ}R6KY$Dt_^9IrHPN!27ab+o@pbFCbXe
z8N@3J%3T}NCr)Qhj@+5JL|vI(Y!|d?r^sURT-|15qg6LPUX6Evh^sSRFrv?81P4NL0ap8BaVOa@F
zSg=pUTfzdr5FiNNuooV}>CVKl^hX~vCvyhwyEqp{76F1t5s2&?CP0i2kp{m8M3x3g
z@_zBOQ$RkT;!jd8edJ>Zf5xEz{-WX?3@Rvj_?k9qx}C5NkkrhGTL=`a&L&)xr7l@h
z_49hcZc^D)zqLw;6-{)r1{O4%absI*pv$m2w5}LeSY~uB)~Q*h%)Ldw-6w@9GQSqY
z;-qS^SYm&hTa%r8xtsSctL7=lXQR{mSpqy;`Ie#cB70Sq`|jK;-3o#X+v|-RE34+`
zk@Fqh3f8j9xP3a*o=91`(P&EW#SfO5YH3dNcN-f@iylN|mW
z{FBhkh?g{_q&{3g&zwj8^SlB
zgs&kmhWzjkDB9(_fhA)o$r_htjmyG$V<-=oj$w7Uatu}BW&Sa&yXu(vE8k&+_+Cln
z#r!u}f)Xrcn_R{&R>oFU&OlaS6Ibf#(tFN%Ki>@)!uymmk{}dkBw+{y4blUtu^ht~
zaotz^ocp+UWCBmTcnuqio(q4El1bG1a1EO|&L781)!*_2u!oOml=G#0n)&Q`lxNBf
zzSf=iJ5~^YW&vOvt)i@L5*<14UzG9AN$ld!*+m{L8^>!qW$n$Zea#y?1_XjlDB!!2
z4puQIVP8^An=^^!kH2um4HSlAA92RdNsBy)v0Z%!e@3D}1{bQW-r?NTS?z$%W