java复制代码import java.util.ArrayList;

public class ShallowCopyAndDeepCopyTest {

    public static class User {

        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }
    }

    public static void main(String[] args) {

        User user = new User();

        user.setName("123");

        ArrayList<User> users1 = new ArrayList<>(),
                users2 = new ArrayList<>();

        users1.add(user);

        users2.add(user);

        System.out.println("user1的0索引位置的对象中的name为: " + users1.get(0).getName());
        System.out.println("user2的0索引位置的对象中的name为: " + users2.get(0).getName());

        users1.get(0).setName("456");

        System.out.println("user1的0索引位置的对象中的name为: " + users1.get(0).getName());
        System.out.println("user2的0索引位置的对象中的name为: " + users2.get(0).getName());

    }
}

java复制代码import java.util.ArrayList;

public class ShallowCopyAndDeepCopyTest {

    /**
     * Cloneable: 实现了该接口后,可以重写Object类中的clone方法,而不抛出CloneNotSupportedException异常
     */
    public static class User implements Cloneable {

        private String name;

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        /**
         * 克隆对象
         */
        public Object clone() throws CloneNotSupportedException {
            return super.clone();
        }

        @Override
        public String toString() {
            return "User{" +
                    "name='" + name + '\'' +
                    '}';
        }
    }

    public static void main(String[] args) throws CloneNotSupportedException {

        User user1 = new User();

        user1.setName("123");

        /* 拷贝对象 */
        User user2 = (User)user1.clone();

        /* 创建新对象 */
        User user3 = new User();

        user3.setName("123");

        ArrayList<User> users1 = new ArrayList<>(),
                users2 = new ArrayList<>(),
                users3 = new ArrayList<>();

        users1.add(user1);
        users2.add(user2);
        users3.add(user3);

        users1.get(0).setName("456");

        System.out.println("user1的0索引位置的对象中的name为: " + users1.get(0).getName());
        System.out.println("user2的0索引位置的对象中的name为: " + users2.get(0).getName());
        System.out.println("user3的0索引位置的对象中的name为: " + users3.get(0).getName());

    }
}

diff复制代码|===订单信息============|      |=======商品信息====================|======支付信息========|
|订单编号|订单状态|下单时间|用户ID|商家ID|商品ID|款式ID|价格|购买数量|运费|支付金额|支付状态|支付时间|

复制代码订单表
|订单编号|订单状态|下单时间|用户ID|商家ID|商品总金额|运费总金额|支付金额|支付状态|支付时间|

复制代码订单商品表
|订单ID|商家ID|商品ID|款式ID|价格|购买数量|支付金额|运费金额|

diff复制代码订单商品表
             |=====商品信息=========|====款式信息==========|   
|订单ID|商家ID|商品ID|商品名称|商品头图|款式ID|款式名称|款式头图|原价|售卖价|下单价格|购买数量|支付金额|运费金额|

复制代码|订单ID|支付类型|下单第三方商户号|下单第三方交易流水号|支付金额|

复制代码订单商品表
|订单ID|商家ID|商品ID|商品名称|商品头图|款式ID|款式名称|款式头图|原价|售卖价|下单价格|购买数量|支付金额|运费金额|结算价|

复制代码订单价格调整表
|订单ID|调整类型|调整金额|关联活动ID|关联活动信息|是否参与计价|

复制代码订单表
|订单编号|订单状态|下单时间|用户ID|商家ID|商品总金额|运费总金额|优惠总金额|支付金额|支付状态|支付时间|

复制代码订单商品表
|订单ID|商家ID|商品ID|商品名称|商品头图|款式ID|款式名称|款式头图|原价|售卖价|下单价格|购买数量|支付金额|运费金额|结算价|优惠金额|下单单价|

python复制代码
from matplotlib import pyplot

import pandas

pyplot.rcParams["font.sans-serif"]=['SimHei']
pyplot.rcParams["axes.unicode_minus"]=False

pyplot.bar([1,2,3,4,5,6],[45,20,19,56,35,69])

pyplot.title("data analyze")
pyplot.xlabel("元素 a")
pyplot.ylabel("元素 b")

pyplot.show()

bash复制代码# yaml 安装
kubectl apply -f https://projectcontour.io/quickstart/contour.yaml
# 验证
kubectl get pod -n projectcontour

bash复制代码# 添加仓库
helm repo add bitnami https://charts.bitnami.com/bitnami  
helm repo update
helm install contour --namespace projectcontour bitnami/contour

bash复制代码$ kubectl get deploy,svc,ds,job -n projectcontour
NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/contour   2/2     2            2           12d

NAME              TYPE           CLUSTER-IP       EXTERNAL-IP 
service/contour   ClusterIP      172.20.126.255   <none>    8001/TCP                     12d
service/envoy     LoadBalancer   172.20.12.164    ...

NAME                   DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
daemonset.apps/envoy   10        10        10      10           10          <none>          12d

bash复制代码$ kubectl get crd|grep contour
contourconfigurations.projectcontour.io                      2021-11-04T13:30:06Z
contourdeployments.projectcontour.io                         2021-11-04T13:30:06Z
extensionservices.projectcontour.io                          2021-11-04T13:30:06Z
httpproxies.projectcontour.io                                2021-11-04T13:30:06Z
tlscertificatedelegations.projectcontour.io                  2021-11-04T13:30:06Z

yaml复制代码apiVersion: projectcontour.io/v1
kind: HTTPProxy
metadata:
  name: name-example-foo
  namespace: default
spec:
  virtualhost:
    fqdn: foo1.bar.com
  routes:
    - conditions:
      - prefix: /
      services:
        - name: s1
          port: 80

yaml复制代码# ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: basic
spec:
  rules:
  - host: foo-basic.bar.com
    http:
      paths:
      - backend:
          service:
            name: s1
            port:
              number: 80

yaml复制代码# httpproxy.yaml
apiVersion: projectcontour.io/v1
kind: HTTPProxy
metadata:
  name: basic
spec:
  virtualhost:
    fqdn: foo-basic.bar.com
  routes:
    - conditions:
      - prefix: /
      services:
        - name: s1
          port: 80

go复制代码// contour/cmd/contour/serve.go
func doServe(log logrus.FieldLogger, ctx *serveContext) error {
  // 这里监听 contour 的 crd 资源, 比如：httpproxy
	for _, r := range k8s.DefaultResources() {
		inf, err := clients.InformerForResource(r)
		......
		inf.AddEventHandler(&dynamicHandler)
	}
  // 监听 ingress 资源
	for _, r := range k8s.IngressV1Resources() {
		if err := informOnResource(clients, r, &dynamicHandler); err != nil {
			log.WithError(err).WithField("resource", r).Fatal("failed to create informer")
		}
	}
  ......
  // 监听 secret 资源
	for _, r := range k8s.SecretsResources() {
    ......
		if err := informOnResource(clients, r, handler); err != nil {
			log.WithError(err).WithField("resource", r).Fatal("failed to create informer")
		}
	}

	// 监听 endpoint 资源
	for _, r := range k8s.EndpointsResources() {
		if err := informOnResource(clients, r, &k8s.DynamicClientHandler{
			Next: &contour.EventRecorder{
				Next:    endpointHandler,
				Counter: contourMetrics.EventHandlerOperations,
			},
			Converter: converter,
			Logger:    log.WithField("context", "endpointstranslator"),
		}); err != nil {
			log.WithError(err).WithField("resource", r).Fatal("failed to create informer")
		}
	}
  ......
}

go复制代码// k8s.io/client-go/tools/cache/controller.go
type ResourceEventHandler interface {
	OnAdd(obj interface{})
	OnUpdate(oldObj, newObj interface{})
	OnDelete(obj interface{})
}

go复制代码func (e *EventHandler) OnAdd(obj interface{}) {
	e.update <- opAdd{obj: obj}
}

func (e *EventHandler) OnUpdate(oldObj, newObj interface{}) {
	e.update <- opUpdate{oldObj: oldObj, newObj: newObj}
}

func (e *EventHandler) OnDelete(obj interface{}) {
	e.update <- opDelete{obj: obj}
}

go复制代码// contour/cmd/contour/server.go
func doServe(log logrus.FieldLogger, ctx *serveContext) error {
	......
  // 启动协程
  g.Add(eventHandler.Start())
  ......
}

// counter/internal/contour/handler.go
func (e *EventHandler) Start() func(<-chan struct{}) error {
	e.update = make(chan interface{})
	return e.run
}

func (e *EventHandler) run(stop <-chan struct{}) error {
	......
  // 死循环，一直监听 channel 中的事件
	for {
		select {
		case op := <-e.update:
			if e.onUpdate(op) {
				......
			}
      ......
 }
  
// 处理事件
// 将资源保存到 e.Builder.Source
func (e *EventHandler) onUpdate(op interface{}) bool {
	switch op := op.(type) {
	case opAdd:
		return e.Builder.Source.Insert(op.obj)
	case opUpdate:
		......
		remove := e.Builder.Source.Remove(op.oldObj)
		insert := e.Builder.Source.Insert(op.newObj)
		return remove || insert
	case opDelete:
		return e.Builder.Source.Remove(op.obj)
	case bool:
		return op
	default:
		return false
	}
}

go复制代码// contour/internal/xdscache/v3/endpointstranslator.go
func (e *EndpointsTranslator) OnAdd(obj interface{}) {
	switch obj := obj.(type) {
	case *v1.Endpoints:
    // 更新本地缓存
		e.cache.UpdateEndpoint(obj)
    // 合并资源
		e.Merge(e.cache.Recalculate())
		e.Notify()
		if e.Observer != nil {
      // 刷新保存快照
			e.Observer.Refresh()
		}
	default:
		e.Errorf("OnAdd unexpected type %T: %#v", obj, obj)
	}
}

go复制代码// contour/internal/dag/cache.go
type KubernetesCache struct {
	......
	ingresses                 map[types.NamespacedName]*networking_v1.Ingress
	ingressclass              *networking_v1.IngressClass
	httpproxies               map[types.NamespacedName]*contour_api_v1.HTTPProxy
	secrets                   map[types.NamespacedName]*v1.Secret
	tlscertificatedelegations map[types.NamespacedName]*contour_api_v1.TLSCertificateDelegation
	services                  map[types.NamespacedName]*v1.Service
	namespaces                map[string]*v1.Namespace
	gatewayclass              *gatewayapi_v1alpha1.GatewayClass
	gateway                   *gatewayapi_v1alpha1.Gateway
	httproutes                map[types.NamespacedName]*gatewayapi_v1alpha1.HTTPRoute
	tlsroutes                 map[types.NamespacedName]*gatewayapi_v1alpha1.TLSRoute
	tcproutes                 map[types.NamespacedName]*gatewayapi_v1alpha1.TCPRoute
	udproutes                 map[types.NamespacedName]*gatewayapi_v1alpha1.UDPRoute
	backendpolicies           map[types.NamespacedName]*gatewayapi_v1alpha1.BackendPolicy
	extensions                map[types.NamespacedName]*contour_api_v1alpha1.ExtensionService
  ......
}

// map中key的数据类型：由 namespace 和 name 共同决定
type NamespacedName struct {
	Namespace string
	Name      string
}

go复制代码// contour/internal/dag/cache.go
func (kc *KubernetesCache) Insert(obj interface{}) bool {
  // 初始化 map，确保执行一次
	kc.initialize.Do(kc.init)
  // 根据不同的资源类型，放入不同的 map
	switch obj := obj.(type) {
	case *v1.Secret:
		......
    // 保存 secret 资源
		kc.secrets[k8s.NamespacedNameOf(obj)] = obj
		return kc.secretTriggersRebuild(obj)
	case *v1.Service:
		kc.services[k8s.NamespacedNameOf(obj)] = obj
		return kc.serviceTriggersRebuild(obj)
	case *v1.Namespace:
		kc.namespaces[obj.Name] = obj
		return true
	......
	}

	return false
}

go复制代码// contour/internal/contour/handler.go
func (e *EventHandler) rebuildDAG() {
  // 将 KubernetesCache 构建成 DAG
	latestDAG := e.Builder.Build()
  // DAG 变更时，通知所有的 Observer，
  // 每种 Observer 是一个 XDS 对象，取出 DAG 资源转换为 XDS 配置
	e.Observer.OnChange(latestDAG)
  // 更新 snapshot 信息
	for _, upd := range latestDAG.StatusCache.GetStatusUpdates() {
		e.StatusUpdater.Send(upd)
	}

}

go复制代码// contour/internal/dag/dag.go
type DAG struct {
	// StatusCache holds a cache of status updates to send.
	StatusCache status.Cache

	// roots are the root vertices of this DAG.
	roots []Vertex
}

// Vertex is a node in the DAG that can be visited.
type Vertex interface {
	Visit(func(Vertex))
}

go复制代码// contour/internal/dag/builder.go
func (b *Builder) Build() *DAG {
	// 先构造一个空的 DAG
  dag := DAG{
		StatusCache: status.NewCache(b.Source.ConfiguredGateway),
	}
 
  // 遍历所有的 processor，每个 processor 把不同的 k8s 资源变成 DAG 的一部分信息
  // 所有的 processor 共同构成完整的 DAG
	for _, p := range b.Processors {
		p.Run(&dag, &b.Source)
	}
	return &dag
}

go复制代码func getDAGBuilder(ctx *serveContext, clients *k8s.Clients, clientCert, fallbackCert *types.NamespacedName, 	log logrus.FieldLogger) dag.Builder {

  dagProcessors := []dag.Processor{
      &dag.IngressProcessor{
        ...
      },
      &dag.ExtensionServiceProcessor{
        ...
      },
      &dag.HTTPProxyProcessor{
       ...
      },
    }
    if ctx.Config.GatewayConfig != nil && clients.ResourcesExist(k8s.GatewayAPIResources()...) {
      dagProcessors = append(dagProcessors, &dag.GatewayAPIProcessor{
        FieldLogger: log.WithField("context", "GatewayAPIProcessor"),
      })
    }
    ...
    dagProcessors = append(dagProcessors, &dag.ListenerProcessor{})
  ...
}

go复制代码func (p *HTTPProxyProcessor) Run(dag *DAG, source *KubernetesCache) {
	...
  // 校验合法性
	for _, proxy := range p.validHTTPProxies() {
    // 计算路由规则
    // 入参为 crd 资源 HttpProxy
    // 内部经过各种计算，构造路由关系，最终保存在DAG中
		p.computeHTTPProxy(proxy)
	}

	for meta := range p.orphaned {
		proxy, ok := p.source.httpproxies[meta]
		if ok {
			pa, commit := p.dag.StatusCache.ProxyAccessor(proxy)
			pa.ConditionFor(status.ValidCondition).AddError(contour_api_v1.ConditionTypeOrphanedError,
				"Orphaned",
				"this HTTPProxy is not part of a delegation chain from a root HTTPProxy")
			commit()
		}
	}
}

go复制代码// contour/internal/contour/handler.go
func (e *EventHandler) rebuildDAG() {
  // 将 KubernetesCache 构建成 DAG
	latestDAG := e.Builder.Build()
  // DAG 变更时，通知所有的 Observer，
  // 每种 Observer 是一个 XDS 对象，取出 DAG 资源转换为 XDS 配置
	e.Observer.OnChange(latestDAG)
  // 更新 snapshot 信息
	for _, upd := range latestDAG.StatusCache.GetStatusUpdates() {
		e.StatusUpdater.Send(upd)
	}
}

go复制代码// contour/cmd/contour/serve.go
func doServe(log logrus.FieldLogger, ctx *serveContext) error {
	 ...
  // ResoureCache 列表
  resources := []xdscache.ResourceCache{
		xdscache_v3.NewListenerCache(listenerConfig, ctx.statsAddr, ctx.statsPort),
		&xdscache_v3.SecretCache{},
		&xdscache_v3.RouteCache{},
		&xdscache_v3.ClusterCache{},
		endpointHandler,
	}
  ...
	eventHandler := &contour.EventHandler{
		...
    // 注册一个组合的 Observer
		Observer:        dag.ComposeObservers(append(xdscache.ObserversOf(resources), snapshotHandler)...),
		...
	}
}

// 组合多个Observer
func ComposeObservers(observers ...Observer) Observer {
	return ObserverFunc(func(d *DAG) {
		for _, o := range observers {
			o.OnChange(d)
		}
	})
}

go复制代码// contour/internal/xdscache/resources.go
type ResourceCache interface {
	dag.Observer
	xds.Resource
}

// contour/internal/dag/dag.go
type Observer interface {
  // 当 DAG变更时，触发相应业务逻辑
	OnChange(*DAG)
}

// contour/internal/xds/resource.go
type Resource interface {
  // 返回全部资源内容
	// Contents returns the contents of this resource.
	Contents() []proto.Message
  
  // 通过给定的名称，返回对应的资源内容
	// Query returns an entry for each resource name supplied.
	Query(names []string) []proto.Message

  // 注册资源
	// Register registers ch to receive a value when Notify is called.
	Register(chan int, int, ...string)

  // 资源类型
	// TypeURL returns the typeURL of messages returned from Values.
	TypeURL() string
}

go复制代码// contour/internal/xdscache/v3/cluster.go
// ClusterCache manages the contents of the gRPC CDS cache.
type ClusterCache struct {
	mu     sync.Mutex
	values map[string]*envoy_cluster_v3.Cluster
	contour.Cond
}

// contour/internal/xdscache/v3/listener.go
// ListenerCache manages the contents of the gRPC LDS cache.
type ListenerCache struct {
	mu           sync.Mutex
	values       map[string]*envoy_listener_v3.Listener
	staticValues map[string]*envoy_listener_v3.Listener

	Config ListenerConfig
	contour.Cond
}

// contour/internal/xdscache/v3/route.go
// RouteCache manages the contents of the gRPC RDS cache.
type RouteCache struct {
	mu     sync.Mutex
	values map[string]*envoy_route_v3.RouteConfiguration
	contour.Cond
}

// contour/internal/xdscache/v3/secret.go
// SecretCache manages the contents of the gRPC SDS cache.
type SecretCache struct {
	mu     sync.Mutex
	values map[string]*envoy_tls_v3.Secret
	contour.Cond
}

// contour/internal/xdscache/v3/endpointstranslator.go
// A EndpointsTranslator translates Kubernetes Endpoints objects into Envoy
// ClusterLoadAssignment resources.
type EndpointsTranslator struct {
	// Observer notifies when the endpoints cache has been updated.
	Observer contour.Observer

	contour.Cond
	logrus.FieldLogger

	cache EndpointsCache

	mu      sync.Mutex // Protects entries.
	entries map[string]*envoy_endpoint_v3.ClusterLoadAssignment
}

go复制代码// contour/internal/xdscache/v3/route.go
func (c *RouteCache) OnChange(root *dag.DAG) {
  // 读取 DAG 中的信息，生成 envoy 的 RDS 资源 envoy_route_v3.RouteConfiguration
	routes := visitRoutes(root)
  // 将配置文件放到 value 字段中，供 Query、Context 等方法调用时查看
	c.Update(routes)
}

go复制代码// contour/internal/xdscache/v3/route.go
func visitRoutes(root dag.Vertex) map[string]*envoy_route_v3.RouteConfiguration {
	// Collect the route configurations for all the routes we can
	// find. For HTTP hosts, the routes will all be collected on the
	// well-known ENVOY_HTTP_LISTENER, but for HTTPS hosts, we will
	// generate a per-vhost collection. This lets us keep different
	// SNI names disjoint when we later configure the listener.
  
  // http 和 https 需要做不同的处理
	rv := routeVisitor{
		routes: map[string]*envoy_route_v3.RouteConfiguration{
			ENVOY_HTTP_LISTENER: envoy_v3.RouteConfiguration(ENVOY_HTTP_LISTENER),
		},
	}

	rv.visit(root)

	for _, v := range rv.routes {
		sort.Stable(sorter.For(v.VirtualHosts))
	}

	return rv.routes
}

// contour/internal/xdscache/v3/route.go
// 从根节点开始查找所有的 Route，查找顺序： Listener -> VirtualHost(SecureVirtualHost) -> Route
func (v *routeVisitor) visit(vertex dag.Vertex) {
	switch l := vertex.(type) {
   // 处理 DAG 中的 Listener
	case *dag.Listener:
		l.Visit(func(vertex dag.Vertex) {
			switch vh := vertex.(type) {
      // 处理 VirtualHost
			case *dag.VirtualHost:
				v.onVirtualHost(vh)
      // 处理 SecureVirtualHost
			case *dag.SecureVirtualHost:
				v.onSecureVirtualHost(vh)
			default:
				// recurse
				vertex.Visit(v.visit)
			}
		})
	default:
		// recurse
		vertex.Visit(v.visit)
	}
}

// 查找 Listener.VirtualHost.Route
func (v *routeVisitor) onVirtualHost(vh *dag.VirtualHost) {
	var routes []*dag.Route

	vh.Visit(func(v dag.Vertex) {
		route, ok := v.(*dag.Route)
		if !ok {
			return
		}
    // 将所有的 route 收集到列表中
		routes = append(routes, route)
	})

	if len(routes) == 0 {
		return
	}

  // 定义了把 dag.Route 对象转换为 envoy_route_v3.Route 对象的方法
  // 将两种数据格式进行转换
	toEnvoyRoute := func(route *dag.Route) *envoy_route_v3.Route {
		...
		rt := &envoy_route_v3.Route{
			Match:  envoy_v3.RouteMatch(route),
			Action: envoy_v3.RouteRoute(route),
		}
		...
		return rt
	}

  // 对 route 排序
	sortRoutes(routes)
  // 这里生成的配置，存储到 routes 这个map中，key 是 ingress_http
	v.routes[ENVOY_HTTP_LISTENER].VirtualHosts = append(v.routes[ENVOY_HTTP_LISTENER].VirtualHosts, toEnvoyVirtualHost(vh, routes, toEnvoyRoute))
}

go复制代码func doServe(log logrus.FieldLogger, ctx *serveContext) error {
	...
  // 用于生成快照，这部分比较简单，不做介绍
  snapshotHandler := xdscache.NewSnapshotHandler(resources, log.WithField("context", "snapshotHandler"))

  ...
  // 注册服务到 GRPC
  // 先通过 NewContourServer 生成一个 GRPC 服务，再注册到 grpcServer
  switch ctx.Config.Server.XDSServerType {
    // 根据启动参数的不同配置，实例化不同的对象
    
    // serverType = "envoy"
		case config.EnvoyServerType:
			v3cache := contour_xds_v3.NewSnapshotCache(false, log)
			snapshotHandler.AddSnapshotter(v3cache)
      // 调用 NewServer 构造对象
      // 这个方法是 go-control-plane 内置的方法
			contour_xds_v3.RegisterServer(envoy_server_v3.NewServer(taskCtx, v3cache, contour_xds_v3.NewRequestLoggingCallbacks(log)), grpcServer)
    // serverType = "contour"，这个是默认配置
		case config.ContourServerType:
      // 调用 NewContourServer 构造对象
			contour_xds_v3.RegisterServer(contour_xds_v3.NewContourServer(log, xdscache.ResourcesOf(resources)...), grpcServer)
  ...
}

go复制代码// contour/internal/xds/v3/server.go

// 以下注册方法均调用的 go-control-plane sdk
// 包括注册 ADS、SDS、CDS、EDS、LDS、RDS
func RegisterServer(srv Server, g *grpc.Server) {
	// register services
	envoy_service_discovery_v3.RegisterAggregatedDiscoveryServiceServer(g, srv)
	envoy_service_secret_v3.RegisterSecretDiscoveryServiceServer(g, srv)
	envoy_service_cluster_v3.RegisterClusterDiscoveryServiceServer(g, srv)
	envoy_service_endpoint_v3.RegisterEndpointDiscoveryServiceServer(g, srv)
	envoy_service_listener_v3.RegisterListenerDiscoveryServiceServer(g, srv)
	envoy_service_route_v3.RegisterRouteDiscoveryServiceServer(g, srv)
}

// 真正实例化的 Server 对象是 `contourServer`
// 将前面准备好的 ResourceCache 列表传进来
func NewContourServer(log logrus.FieldLogger, resources ...xds.Resource) Server {
	c := contourServer{
		FieldLogger: log,
		resources:   map[string]xds.Resource{},
	}
  // 按照 TypeURL 作为 key，保存资源
	for i, r := range resources {
		c.resources[r.TypeURL()] = resources[i]
	}

	return &c
}

go复制代码// contour/internal/xds/v3/contour.go
type contourServer struct {
   // Since we only implement the streaming state of the world
   // protocol, embed the default null implementations to handle
   // the unimplemented gRPC endpoints.
   envoy_service_discovery_v3.UnimplementedAggregatedDiscoveryServiceServer
   envoy_service_secret_v3.UnimplementedSecretDiscoveryServiceServer
   envoy_service_route_v3.UnimplementedRouteDiscoveryServiceServer
   envoy_service_endpoint_v3.UnimplementedEndpointDiscoveryServiceServer
   envoy_service_cluster_v3.UnimplementedClusterDiscoveryServiceServer
   envoy_service_listener_v3.UnimplementedListenerDiscoveryServiceServer

   logrus.FieldLogger
   // 所有生成的 Envoy XDS 信息都传进来保存到这个字段
   resources   map[string]xds.Resource
   connections xds.Counter
}

go复制代码func (s *contourServer) StreamClusters(srv envoy_service_cluster_v3.ClusterDiscoveryService_StreamClustersServer) error {
	return s.stream(srv)
}

func (s *contourServer) StreamEndpoints(srv envoy_service_endpoint_v3.EndpointDiscoveryService_StreamEndpointsServer) error {
	return s.stream(srv)
}

func (s *contourServer) StreamListeners(srv envoy_service_listener_v3.ListenerDiscoveryService_StreamListenersServer) error {
	return s.stream(srv)
}

func (s *contourServer) StreamRoutes(srv envoy_service_route_v3.RouteDiscoveryService_StreamRoutesServer) error {
	return s.stream(srv)
}

func (s *contourServer) StreamSecrets(srv envoy_service_secret_v3.SecretDiscoveryService_StreamSecretsServer) error {
	return s.stream(srv)
}

go复制代码func (s *contourServer) stream(st grpcStream) error {
	...
  // 持续监听连接，并处理请求
	// now stick in this loop until the client disconnects.
	for {
		// 获取 envoy 发送来的请求
		req, err := st.Recv()
		...
    // 根据请求的 TypeURL，找到匹配的 ResourceCache
		r, ok := s.resources[req.GetTypeUrl()]
		...
    // 注册监听器
		r.Register(ch, last, req.ResourceNames...)
		select {
		case last = <-ch:
			
			var resources []proto.Message
			switch len(req.ResourceNames) {
      // 如果没有指定资源名称，返回所有资源
			case 0:
				// 调用前面介绍过的 Contents 方法，从 ResourceCache 的 value 中取到 envoy 配置
				resources = r.Contents()
      // 如果指定资源名称，查找特定资源
			default:
				// resource hints supplied, return exactly those
				resources = r.Query(req.ResourceNames)
			}
      // 将 ResourceCache 转换成 PB 数据
			any := make([]*any.Any, 0, len(resources))
			for _, r := range resources {
				a, err := anypb.New(proto.MessageV2(r))
				if err != nil {
					return done(log, err)
				}
				any = append(any, a)
			}
      // 构造 grpc response 对象
			resp := &envoy_service_discovery_v3.DiscoveryResponse{
				VersionInfo: strconv.Itoa(last),
				Resources:   any,
				TypeUrl:     req.GetTypeUrl(),
				Nonce:       strconv.Itoa(last),
			}

      // 将 response 通过 grpc 发送给客户端 envoy
			if err := st.Send(resp); err != nil {
				return done(log, err)
			}

		case <-ctx.Done():
			return done(log, ctx.Err())
		}
	}
}

yaml复制代码initContainers:
- args:
  - bootstrap
  - /config/envoy.json
  - --xds-address=contour
  - --xds-port=8001
  - --xds-resource-version=v3
  - --resources-dir=/config/resources
  - --envoy-cafile=/certs/ca.crt
  - --envoy-cert-file=/certs/tls.crt
  - --envoy-key-file=/certs/tls.key

bash复制代码kubectl -n projectcontour exec -it envoy-65qfq -c envoy -- cat /config/envoy.json

yaml复制代码{
    "static_resources": {
        "clusters": [
            {
                "name": "contour",
                "alt_stat_name": "projectcontour_contour_8001",
                "type": "STRICT_DNS",
                "connect_timeout": "5s",
                "load_assignment": {
                    "cluster_name": "contour",
                    "endpoints": [
                        {
                            "lb_endpoints": [
                                {
                                    "endpoint": {
                                        "address": {
                                            "socket_address": {
                                                "address": "contour",
                                                "port_value": 8001
                                            }
                                        }
                                    }
                                }
                            ]
                        }
                    ]
                },
                "circuit_breakers": {
                    "thresholds": [
                        {
                            "priority": "HIGH",
                            "max_connections": 100000,
                            "max_pending_requests": 100000,
                            "max_requests": 60000000,
                            "max_retries": 50
                        },
                        {
                            "max_connections": 100000,
                            "max_pending_requests": 100000,
                            "max_requests": 60000000,
                            "max_retries": 50
                        }
                    ]
                },
                "typed_extension_protocol_options": {
                    "envoy.extensions.upstreams.http.v3.HttpProtocolOptions": {
                        "@type": "type.googleapis.com/envoy.extensions.upstreams.http.v3.HttpProtocolOptions",
                        "explicit_http_config": {
                            "http2_protocol_options": {}
                        }
                    }
                },
                "transport_socket": {
                    "name": "envoy.transport_sockets.tls",
                    "typed_config": {
                        "@type": "type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext",
                        "common_tls_context": {
                            "tls_params": {
                                "tls_maximum_protocol_version": "TLSv1_3"
                            },
                            "tls_certificate_sds_secret_configs": [
                                {
                                    "name": "contour_xds_tls_certificate",
                                    "sds_config": {
                                        "path": "/config/resources/sds/xds-tls-certificate.json",
                                        "resource_api_version": "V3"
                                    }
                                }
                            ],
                            "validation_context_sds_secret_config": {
                                "name": "contour_xds_tls_validation_context",
                                "sds_config": {
                                    "path": "/config/resources/sds/xds-validation-context.json",
                                    "resource_api_version": "V3"
                                }
                            }
                        }
                    }
                },
                "upstream_connection_options": {
                    "tcp_keepalive": {
                        "keepalive_probes": 3,
                        "keepalive_time": 30,
                        "keepalive_interval": 5
                    }
                }
            },
            {
                "name": "envoy-admin",
                "alt_stat_name": "projectcontour_envoy-admin_9001",
                "type": "STATIC",
                "connect_timeout": "0.250s",
                "load_assignment": {
                    "cluster_name": "envoy-admin",
                    "endpoints": [
                        {
                            "lb_endpoints": [
                                {
                                    "endpoint": {
                                        "address": {
                                            "pipe": {
                                                "path": "/admin/admin.sock",
                                                "mode": 420
                                            }
                                        }
                                    }
                                }
                            ]
                        }
                    ]
                }
            }
        ]
    },
    "dynamic_resources": {
        "lds_config": {
            "api_config_source": {
                "api_type": "GRPC",
                "transport_api_version": "V3",
                "grpc_services": [
                    {
                        "envoy_grpc": {
                            "cluster_name": "contour"
                        }
                    }
                ]
            },
            "resource_api_version": "V3"
        },
        "cds_config": {
            "api_config_source": {
                "api_type": "GRPC",
                "transport_api_version": "V3",
                "grpc_services": [
                    {
                        "envoy_grpc": {
                            "cluster_name": "contour"
                        }
                    }
                ]
            },
            "resource_api_version": "V3"
        }
    },
    "admin": {
        "access_log": [
            {
                "name": "envoy.access_loggers.file",
                "typed_config": {
                    "@type": "type.googleapis.com/envoy.extensions.access_loggers.file.v3.FileAccessLog",
                    "path": "/dev/null"
                }
            }
        ],
        "address": {
            "pipe": {
                "path": "/admin/admin.sock",
                "mode": 420
            }
        }
    }
}

sql复制代码mysql> SHOW DATABASES;

sql复制代码mysql> CREATE DATABASE create_test CHARSET = 'utf8';

sql复制代码mysql> USE create_test;

sql复制代码mysql> SELECT DATABASE();
+-------------+
| DATABASE()  |
+-------------+
| create_test |
+-------------+

sql复制代码mysql> DROP DATABASE create_test;

sql复制代码CREATE TABLE  [IF NOT EXISTS] `表名` (
	`字段名` 列类型 [属性] [索引] [注释]，
	`字段名` 列类型 [属性] [索引] [注释]，
	.......
	`字段名` 列类型 [属性] [索引] [注释]
) [表类型] [字符集设置] [注释]

sql复制代码mysql> CREATE TABLE one_piece
    -> (
    ->     id CHAR(10) NOT NULL COMMENT '海贼团id',
    ->     pirates CHAR(10) NOT NULL COMMENT '海贼团名称',
    ->     name CHAR(10) NOT NULL COMMENT '海贼名',
    ->     age INT(11) NOT NULL COMMENT '海贼年龄',
    ->     post VARCHAR(10) NULL COMMENT '海贼团职位'
    -> );

sql复制代码mysql> ALTER TABLE one_piece
    -> ADD bounty INT(15);

sql复制代码mysql> ALTER TABLE one_piece
    -> DROP COLUMN bounty;

sql复制代码mysql> DESC one_piece;
+---------+-------------+------+-----+---------+-------+
| Field   | Type        | Null | Key | Default | Extra |
+---------+-------------+------+-----+---------+-------+
| id      | char(10)    | NO   |     | NULL    |       |
| pirates | char(10)    | NO   |     | NULL    |       |
| name    | char(10)    | NO   |     | NULL    |       |
| age     | int(11)     | YES  |     | NULL    |       |
| post    | varchar(10) | YES  |     | NULL    |       |
+---------+-------------+------+-----+---------+-------+

sql复制代码mysql> SHOW TABLE STATUS LIKE 'one_piece' \G
*************************** 1. row ***************************
           Name: one_piece
         Engine: InnoDB
        Version: 10
     Row_format: Dynamic
           Rows: 0
 Avg_row_length: 0
    Data_length: 16384
Max_data_length: 0
   Index_length: 0
      Data_free: 0
 Auto_increment: NULL
    Create_time: 2021-11-08 15:20:13
    Update_time: NULL
     Check_time: NULL
      Collation: utf8mb4_0900_ai_ci
       Checksum: NULL
 Create_options:
        Comment:

sql复制代码-- 方法一
mysql> ALTER TABLE one_piece RENAME TO new_one_piece;
-- 方法二
mysql> RENAME TABLE new_one_piece TO one_piece;

sql复制代码mysql> DROP TABLE one_piece;

sql复制代码mysql> SELECT name, age
    -> FROM one_piece;

sql复制代码mysql> SELECT DISTINCT age
    -> FROM one_piece;

sql复制代码SELECT * FROM table  LIMIT [offset], rows    -- LIMIT 单独使用
SELECT * FROM table  LIMIT rows OFFSET [offset]    -- 配合 OFFSET 使用

sql复制代码SELECT * FROM one_piece LIMIT 5;    -- 检索前5条数据
--相当于
SELECT * from one_piece LIMIT 0,5;    -- 从第0行开始检索5条数据
--相当于
SELECT * FROM one_piece LIMIT 5 OFFSET 0;    -- 从第0行开始检索5条数据，注意这里的LIMIT的5指代的是数量

sql复制代码-- 单行注释
# 单行注释
/* 多行注释 */

sql复制代码mysql> SELECT name, age
    -> FROM one_piece
    -> ORDER BY age;

sql复制代码mysql> SELECT A, B
    -> FROM test
    -> ORDER BY A, B;

sql复制代码mysql> SELECT age
    -> FROM one_piece
    -> ORDER BY age DESC;

sql复制代码mysql> SELECT name, age
    -> FROM one_piece
    -> ORDER BY name DESC, age;

sql复制代码mysql> SELECT age
    -> FROM one_piece
    -> WHERE A BETWEEN 5 AND 10;

sql复制代码mysql> SELECT name
    -> FROM one_piece
    -> WHERE name IS NULL;

sql复制代码mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE(name = '索隆' OR name = '路飞')
    -> AND age >= 18;

sql复制代码mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE name IN ('索隆', '路飞')

sql复制代码mysql> SELECT name
    -> FROM one_piece
    -> WHERE name NOT IN ('索隆', '路飞')

sql复制代码mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE name LIKE '路%';

sql复制代码mysql> SELECT name, age
    -> FROM one_piece
    -> WHERE name LIKE '乌_普';

java复制代码	// 取goods与category的交集，结果放到result中		
        redisTemplate.opsForZSet().intersectAndStore(goods,category,result);
        int start = (pageNum-1) * pageSize;
	// 分页获取集合
        Set<ZSetOperations.TypedTuple<Object>> rangeWithScores = redisTemplate.opsForZSet().reverseRangeWithScores(result, start, pageSize - 1);
        System.out.println(rangeWithScores);

java复制代码        // 查询goodId对应的类别
	List<Object> categoryList = (List<Object>) redisHash.hGet("good:categorys",goodId);
        // 查询上面查出类别的价格
	List idxPriceList = redisHash.multiGet("category",categoryList);

        List<Map> idxList = new ArrayList<>();
        for (int i = 0;i<boardList.size();i++){
            Map<String, Object> idxM = new HashMap<>();
            idxM.put("k",boardList.get(i));
            idxM.put("v",idxPriceList.get(i));
            idxList.add(idxM);
        }
	// 种类按价格排序
        idxList.sort((o1, o2) -> {
                return (o1.get("v").toString()).compareTo(o2.get("v").toString());
        });
	System.out.println(idxList);
       // 获取最高物品的代码
       String code = idxList.get(0).get("k").toString();
        // 种类下的物品
        List<Object> sList = (List<Object>) redisHash.hGet("category:goods",code);

        // 查找物品对应价格
        List codeList = redisHash.multiGet("good:price",sList);

        List<Map> codeIdxList = new ArrayList<>();
        for (int i = 0;i<sList.size();i++){
            Map<String, Object> idxM = new HashMap<>();
            if(null != codeList.get(i)){
                idxM.put("k",sList.get(i));
                idxM.put("v",codeList.get(i));
                codeIdxList.add(idxM);
            }
        }

       // 按价格排序
        codeIdxList.sort((o1, o2) -> {
                return (o1.get("v").toString()).compareTo(o2.get("v").toString());
        });
        // 分页获取数据
        codeIdxList = codeIdxList.stream().limit(pageSize).collect(Collectors.toList());
        
        System.out.println(codeIdxList);

go复制代码package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

// 根据文件名，段名，键名获取ini的值
func getValue(filename, expectSection, expectKey string) string {
	// 打开文件
	file, err := os.Open(filename)
	// 文件找不到，返回空
	if err != nil {
		return "123"
	}
	// 在函数结束时，关闭文件
	defer file.Close()
	// 使用读取器读取文件
	reader := bufio.NewReader(file)
	// 当前读取的段的名字
	var sectionName string
	for {
		// 读取文件的一行
		linestr, err := reader.ReadString('\n')
		if err != nil {
			break
		}
		// 切掉行的左右两边的空白字符
		linestr = strings.TrimSpace(linestr)
		// 忽略空行
		if linestr == "" {
			continue
		}
		// 忽略注释
		if linestr[0] == ';' {
			continue
		}
		// 行首和尾巴分别是方括号的，说明是段标记的起止符
		if linestr[0] == '[' && linestr[len(linestr)-1] == ']' {
			// 将段名取出
			sectionName = linestr[1 : len(linestr)-1]
			// 这个段是希望读取的
		} else if sectionName == expectSection {
			// 切开等号分割的键值对
			pair := strings.Split(linestr, "=")
			// 保证切开只有1个等号分割的简直情况
			if len(pair) == 2 {
				// 去掉键的多余空白字符
				key := strings.TrimSpace(pair[0])
				// 是期望的键
				if key == expectKey {
					// 返回去掉空白字符的值
					return strings.TrimSpace(pair[1])
				}
			}
		}
	}
	return "123123"
}

func main() {
	fmt.Println(getValue("woner.ini", "Mail", "CMCDLLNAME32"))
}

go复制代码fmt.Println(getValue("woner.ini", "Mail", "CMCDLLNAME32")) //调用函数