wangbaochen (王宝臣)

# Visual Studio 远程调试

wangbaochen — Wed, 29 Dec 2021 08:21:01 +0800

Visual Studio 远程调试

在可以远程对方电脑，并且只有在对方电脑上出现 BUG 时，可以使用远程调试功能

原理

目标机：

负责执行目标程序。安装和运行远程工具（Remote Debugger），等待来自开发机的连接请求。

开发机：

将编译好的程序部署到目标机器上执行。配置 VS 工程，建立与目标机的连接，开始远程调试。

环境要求

目标机必须满足：

Windows 7 以后或者 Windows Server 2008 Service Pack 2 以后。

网络必须满足：

目标机和开发机必须通过网络、工作组、家庭组连接，或者通过网线直连。

安装 Remote Debugger

在你本地的 VS 安装目录下找到 msvsmon.exe，此文件就是 Remote Debugger。

它的位置在：

C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\Common7\IDE\Remote Debugger\x86\msvsmon.exe
C:\Program Files (x86)\Microsoft Visual Studio\2017\Enterprise\Common7\IDE\Remote Debugger\x64\msvsmon.exe

可以共享该目录，在目标机上直接运行 Share Folder 中的 msvsmon.exe 即可。

也可以把 msvsmon.exe 所在的整个目录 Copy 到目标机上。

这里同样需要注意，要与目标机的操作系统位数匹配。

配置 Remote Debugger

这一步还是在目标机上。

所在登陆账户，一定要拥有管理员权限。

打开安装好的 Remote Debugger (msvsmon.exe)，首次打开时，会出现配置窗口，提醒配置一些参数。

只需要配置一次，再次打开时，不会弹出该窗口。

如果你不清楚你的网络连接方式，比较保险的做法是把所有框都勾选上。

点击配置远程调试按钮之后，会出现如下窗口，代表 Remote Debugger 正在等待来自开发机的连接。

这里可以点击工具 > 选项菜单，做一些额外的参数配置。建议选择无身份验证，防止连接失败

有时可能会由于防火墙或者认证等原因，导致连接不上的问题，最极端的方法是完全关闭它们。虽然官方出于安全考虑，并不建议这么做。

假如你确定网络没有任何风险，那么可以关闭两边机器的防火墙。上面窗口中，也可以选择无认证方式。

最大空闲时间设置为 0 代表永远不会超时，一直处于等待状态。

TCP/IP 端口号这里默认给出的是 4022，你可以更改，但一般无需这样做。

调试

连接类型：选择远程 (无身份验证)
连接目标：目标机 IP:端口号

点击查找，找到目标用户并连接，然后附加到进程

连接到目标机后，选则需要调试的进程，如上图：

连接成功后，目标机会显示，开发机用户。

要调试的 DLL 必须时 DEBUG 模式，否则不能击中断点

WnGrid 添加 Image 列

wangbaochen — Mon, 20 Dec 2021 09:57:10 +0800

WnGrid 添加 ImageColumn

修改类型为 byte[] 列为 Image 列，此前为 Text 列。添加 ImageShowMode 属性。
修改 WnImage 单值控件存储数据逻辑，添加 ImageShowInWnGrid 属性。
修改 ExportData 方法，添加 IsExistImageColumn 属性

ImageShowMode

图片展示模式（PictureSizeMode）枚举类型

Clip：图片没有被拉伸，原图，若图片需要导出推荐使用此模式
Stretch：图片被拉伸，以适应编辑器
Zoom：图片被按比例拉长。图片至少在一个方向上适合编辑器，若要当作缩略图显示，推荐此模式
StretchHorizontal：图片被水平拉长。其高度保持不变
StretchVertical：图片被垂直拉长。其宽度保持不变
Squeeze：图像的实际尺寸小于容器的尺寸，则按原样显示。如果图像的尺寸大于容器的尺寸，图像将按比例缩小以适应容器的边界

ImageShowInWnGrid

是否在 WnGrid 中展示图片（bool）

为兼容此前的数据存储模式添加，此前 Image 通过 BinaryFormatter 序列化为 byte[]，如果需要在 WnGrid 中展示图片则 Image 不能被序列化，需要原始 byte[]。

IsExistImageColumn

导出的文件中是否存在图片 (bool)

DefaultExportType 为 WYSIWYG 可以导出图片，默认为 Default。

WnForm 扩展工具 (Visual Studio 扩展)

wangbaochen — Fri, 22 Oct 2021 17:08:31 +0800

WnFormExt

WnForm 扩展工具

编译条件

Visual Studio 2022 Preview
Extensibility Essentials 2022

安装

自行编译为 vsix 安装即可。

界面展示

设置

安装完毕后在工具列表中展示	打开之后在右侧显示（若没有修改过界面布局）

添加代码片段

查找代码片段

主要功能

引用替换
拷贝
代码片段管理

引用

项目引用的程序集位置发生变更时，需要重新手动更换，引用替换功能可以根据指定的引用地址一键替换。

引用地址存在两处，工具>选项>WnForm 扩展工具>常规和工具界面，界面的优先级>常规

替换完毕后需要重新加载项目

关闭并拷贝

~~先关闭打开时间最近的 WnForm 程序~~ 先将占用拷贝文件的线程关闭，再将项目生成的类库拷贝到指定目录

拷贝目录存在两处，工具>选项>WnForm 扩展工具>常规和工具界面，界面的优先级>常规

代码片段管理

代码片段是小块可重用代码，可通过右键单击菜单（关联菜单）命令或热键组合插入到代码文件中。代码片段通常包含常用的代码块（如 try-finally 或 if-else 块），可用于插入整个类或方法。

添加代码片段

首先在设置中指定自定义代码片段位置 (一次即可)
在工具>代码片段管理器>选择语言 (eg. CSharp)>添加自定义代码片段位置 (一次即可)
选中要添加的代码
填写名称、作者、快捷键、详情等信息

添加完毕之后，输入快捷方式，按下两次 Tab 键，加载代码

查找代码片段

解析，会将 Visual Studio 自带的代码片段和自定义的代码片段解析到 SQLite 中方便查询
根据名称、详细信息、代码查找输入的内容并以树展示，输入内容为空则查找所有
展开树节点后，双击显示详细信息

解析文件存放位置：C:\Users{name}\AppData\Local\MySQLiteDB\MyDB.sqlite

代码链接

https://git.xxb.lttc.cn/wangbc/WnFormExt

打印完毕自动关闭预览脚本

wangbaochen — Sat, 04 Sep 2021 09:54:20 +0800

引用

在脚本引用中添加

DevExpress.XtraPrinting.v18.1.dll
DevExpress.Utils.v18.1.dll

编写脚本

XtraReport 通过 PrintingSystemBase 基类进行打印，在打印前记录当前 XtraReport ，在打印文件发送到打印机后（EndPrint 事件），关闭预览界面。

@zhangrui 张锐提供不要直接复制黏贴代码，需要手动选择当前报表 (PrintObject) 的 BeforePrint 事件，否则无法触发 BeforePrint 事件

XtraReport report;
private void PrintObject_BeforePrint(object sender, System.Drawing.Printing.PrintEventArgs e) {
 report = (sender as XtraReport); 
 report.PrintingSystem.EndPrint += PrintingSystem_EndPrint;  
}

private void PrintingSystem_EndPrint(object sender, EventArgs e) {  
 report.ClosePreview();  
}

C# 调用 exe 文件

wangbaochen — Sat, 04 Sep 2021 09:52:58 +0800

WinForm 系统方案

通过配置通用模块【APP.WnEmbeddedForm】打开 exe 文件，此方案无法传参,需将文件放入 WinForm 所在文件夹中。

配置参数：ParamInfo
Folder:exe 文件所在的文件夹
File:exe 文件名称
ModuleName:模块打开时所展示的名称

e.g.:

代码方案

调用外部 exe 并且传参，无返回值。


public static void RunExeByProcess(string exePath, string argument)
{
 //创建进程
 System.Diagnostics.Process process = new System.Diagnostics.Process();

 //调用的exe的名称
 process.StartInfo.FileName = exePath;

 //传递进exe的参数 -- 参数以空格分隔，如果某个参数为空，可以传入”” 
 process.StartInfo.Arguments = argument;

 //是否需要系统shell调用程序
 process.StartInfo.UseShellExecute = false;

 //不显示exe的界面
 process.StartInfo.CreateNoWindow = true;

 //输出
 process.StartInfo.RedirectStandardOutput = true;
 process.StartInfo.RedirectStandardInput = true;
 process.Start();

 process.StandardInput.AutoFlush = true;

 //阻塞等待调用结束
 process.WaitForExit();
}

调用外部 exe 并且传参，有返回值。

public static string RunExeByProcess(string exePath, string argument)
  {
   //创建进程
   System.Diagnostics.Process process = new System.Diagnostics.Process();

   //调用的exe的名称
   process.StartInfo.FileName = exePath;

   //传递进exe的参数
   process.StartInfo.Arguments = argument;
   process.StartInfo.UseShellExecute = false;

   //不显示exe的界面
   process.StartInfo.CreateNoWindow = true;
   process.StartInfo.RedirectStandardOutput = true;
   process.StartInfo.RedirectStandardInput = true;
   process.Start();

   process.StandardInput.AutoFlush = true;

   string result = null;
   while (!process.StandardOutput.EndOfStream)
   {
    result += process.StandardOutput.ReadLine() + Environment.NewLine;
   }

   process.WaitForExit();
   return result;
  }

AOP 编程思想

wangbaochen — Tue, 13 Jul 2021 11:25:12 +0800

AOP 编程思想

一、什么是 AOP

AOP：Aspect Oriented Programming 的缩写，意为面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP 是 OOP 思想的延续。利用 AOP 可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

二、编程思想的发展路线

1、POP

POP：Procedure Oriented Programming 的缩写，即面向过程编程，是一种以过程为中心的编程思想。

面向过程是分析出解决问题的步骤，然后用函数或者方法，把这些步骤一步一步的实现，使用的时候在一个一个的一次调用函数或者方法，这就是面向过程编程。最开始的时候都是面向过程编程。面向过程是最为实际的一种思考方式。就算是面向对象编程，里面也是包含有面向过程的编程思想，因为面向过程是一种基础的编程思考方式，它从实际出发来考虑如何实现需求。

POP 的不足：面向过程编程，只能处理一些简单的问题，无法处理一些复杂的问题。如果问题很复杂，全部以流程来思考的话，会发现流程很混乱，甚至流程都不能进行下去。

2、OOP

OOP：Object Oriented Programming 的缩写，即面向对象编程。

早期的计算机编程都是面向过程的，因为早期的编程都比较简单。但是随着时间的发展，需求处理的问题越来越多，问题就会越来越复杂，这时就不能简单的使用面向过程的编程了，就出现了面向对象编程。在计算机里面，把所有的东西都想象成一种事物。现实世界中的对象都有一些属性和行为，也就对应计算机中的属性和方法。

面向对象编程就是把构成问题的事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描述某个事物在整个解决问题的步骤中的行为。

OOP 的不足：产生新的需求会导致程序代码不断的进行修改，容易造成程序的不稳定。

如果非常了解 OOP 的话，那么我们应该知道，从对象的组织角度来讲，分类方法都是以继承关系为主线的，我们称为纵向。如果只使用 OOP 思想的话，会带来两个问题：

共性问题。
扩展问题，需要对先有类进行扩展时就比较困难了。

OOP 与 POP 的区别：

在对比面向过程的时候，面向对象的方法是把事物最小化为对象，包括属性和方法。当程序的规模比较小的时候，面向过程编程还是有一些优势的，因为这时候程序的流程是比较容易梳理清楚的。以早上去上班为例，过程就是起床、穿衣、刷牙洗脸、去公司。每一步都是按照顺序完成的，我们只需要按照步骤去一步一步的实现里面的方法就行了，最后在依次调用实现的方法即可，这就是面向过程开发。

如果使用面向对象编程，我们就需要抽象出来一个员工类，该员工具有起床、穿衣、刷牙洗脸、去公司的四个方法。但是，最终要实现早上去上班的这个需求的话，还是要按照顺序依次来调用四个方法。最开始的时候，我们是按照面向过程的思想来思考该需求，然后在按照面向对象的思想来抽象出几个方法，最终要实现这个需求，还是要按照面向过程的顺序来实现。

面向对象和面向过程的区别仅仅是在思考问题方式上面的不同。最终你会发现，在你实现这个需求的时候，即使使用了面向对象的思想抽象出来了员工类，但是最后还是要使用面向过程来实现这个需求。

3、AOP

AOP：Aspect Oriented Programming 的缩写，即面向切面编程。是对 OOP 的一种补充，在不修改原始类的情况下，给程序动态添加统一功能的一种技术。

OOP 关注的是将需求功能划分为不同的并且相对独立、封装良好的类，依靠继承和多态来定义彼此的关系。AOP 能够将通用需求功能从不相关的类中分离出来，很多类共享一个行为，一旦发生变化，不需要去修改很多类，只需要去修改这一个类即可。

AOP 中的切面是指什么呢？切面指的是横切关注点。看下面一张图：

OOP 是为了将状态和行为进行模块化。上图是一个商场系统，我们使用 OOP 将该系统纵向分为订单管理、商品管理、库存管理模块。在该系统里面，我们要进行授权验证。像订单、商品、库存都是业务逻辑功能，但是这三个模块都需要一些共有的功能，比如说授权验证、日志记录等。我们不可能在每个模块里面都去写授权验证，而且授权验证也不属于具体的业务，它其实属于功能性模块，并且会横跨多个业务模块。可以看到这里是横向的，这就是所谓的切面。通俗的将，AOP 就是将公用的功能给提取出来，如果以后这些公用的功能发生了变化，我们只需要修改这些公用功能的代码即可，其它的地方就不需要去更改了。所谓的切面，就是只关注通用功能，而不关注业务逻辑，而且不修改原有的类。

AOP 优势：

将通用功能从业务逻辑中抽离出来，提高代码复用性，有利于后期的维护和扩展。
软件设计时，抽出通用功能（切面），有利于软件设计的模块化，降低软件架构的复杂度。

AOP 的劣势：

AOP 的对 OOP 思想的一种补充，它无法单独存在。如果说单独使用 AOP 去设计一套系统是不可能的。在设计系统的时候，如果系统比较简单，那么可以只使用 POP 或者 OOP 来设计。如果系统很复杂，就需要使用 AOP 思想。首先要使用 POP 来梳理整个业务流程，然后根据 POP 的流程，去整理类和模块，最后在使用 AOP 来抽取通用功能。

AOP 和 OOP 的区别：

面向目标不同：OOP 是面向名词领域 (抽象出来一个事物，比如学生、员工，这些都是名词)。AOP 是面向动词领域 (比如鉴权、记录日志，这些都是动作或行为)。
思想结构不同：OOP 是纵向的 (以继承为主线，所以是纵向的)。AOP 是横向的。
注重方面不同：OOP 是注重业务逻辑单元的划分，AOP 偏重业务处理过程中的某个步骤或阶段。

POP、OOP、AOP 三种思想是相互补充的。在一个系统的开发过程中，这三种编程思想是不可或缺的。

三、实现 AOP

实现 AOP 有两种方式：

静态代理实现。所谓静态代理，就是我们自己来写代理对象。
动态代理实现。所谓动态代理，就是在程序运行时，去生成一个代理对象。

1、静态代理

实现静态代理需要使用到两种设计模式：装饰器模式和代理模式。

装饰器模式：允许向一个现有的对象添加新的功能，同时又不改变这个现有对象的结构。属于结构型设计模式，它是作为现有类的一种包装。首先会创建一个装饰类，用来包装原有的类，并在保持类的完整性的前提下，提供额外的功能。看下面的例子。

我们首先创建一个 User 类：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace StaticDemo.Model
{
    public class User
    {
        public string Name { get; set; }
        public string Password { get; set; }
    }
}

接着我们创建一个账号服务的接口，里面有一个方法，用来注册一个用户：

using StaticDemo.Model;

namespace StaticDemo.Services
{
    /// <summary>
    /// 接口
    /// </summary>
    public interface IAccountService
    {
        /// <summary>
        /// 注册用户
        /// </summary>
        /// <param name="user"></param>
        void Reg(User user);
    }
}

然后创建一个类来实现上面的接口：

using StaticDemo.Model;
using System;

namespace StaticDemo.Services
{
    /// <summary>
    /// 实现IAccountService接口
    /// </summary>
    public class AccountService : IAccountService
    {
        public void Reg(User user)
        {
            // 业务代码 之前 或者之后执行一些其它的逻辑
            Console.WriteLine($"{user.Name}注册成功");
        }
    }
}

我们在创建一个装饰器类：

using StaticDemo.Model;
using StaticDemo.Services;
using System;

namespace StaticDemo
{
    /// <summary>
    /// 装饰器类
    /// </summary>
    public class AccountDecorator : IAccountService
    {
        private readonly IAccountService _accountService;

        public AccountDecorator(IAccountService accountService)
        {
            _accountService = accountService;
        }

        public void Reg(User user)
        {
            Before();
            // 这里调用注册的方法，原有类里面的逻辑不会改变
            // 在逻辑前面和后面分别添加其他逻辑
            _accountService.Reg(user);
            After();
        }

        private void Before()
        {
            Console.WriteLine("注册之前的逻辑");
        }

        private void After()
        {
            Console.WriteLine("注册之后的逻辑");
        }
    }
}

我们会发现装饰器类同样实现了 IAccountService 接口。最后我们在 Main 方法里面调用：

using StaticDemo.Model;
using StaticDemo.Services;
using System;

namespace StaticDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            // 实例化对象
            IAccountService accountService = new AccountService();
            // 实例化装饰器类，并用上面的实例给构造方法传值
            var account = new AccountDecorator(accountService);
            var user = new User { Name = "Rick", Password = "12345678" };
            // 调用装饰器类的注册方法，相当于调用实例化对象的注册方法
            account.Reg(user);

            Console.ReadKey();
        }
    }
}

运行结果：

下面我们在来看看如何使用代理模式实现。

using StaticDemo.Model;
using StaticDemo.Services;
using System;

namespace StaticDemo
{
    /// <summary>
    /// 代理类
    /// </summary>
    public class ProxyAccount : IAccountService
    {
        private readonly IAccountService _accountService;

        /// <summary>
        /// 构造函数没有参数
        /// 直接在里面创建了AccountService类
        /// </summary>
        public ProxyAccount()
        {
            _accountService = new AccountService();
        }

        public void Reg(User user)
        {
            before();
            _accountService.Reg(user);
            after();
        }

        private void before()
        {
            Console.WriteLine("代理：注册之前的逻辑");
        }

        private void after()
        {
            Console.WriteLine("代理：注册之后的逻辑");
        }
    }
}

Main 方法里面调用：

using StaticDemo.Model;
using StaticDemo.Services;
using System;

namespace StaticDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            #region 装饰器模式
            //// 实例化对象
            //IAccountService accountService = new AccountService();
            //// 实例化装饰器类，并用上面的实例给构造方法传值
            //var account = new AccountDecorator(accountService);
            //var user = new User { Name = "Rick", Password = "12345678" };
            //// 调用装饰器类的注册方法，相当于调用实例化对象的注册方法
            //account.Reg(user);
            #endregion

            #region 代理模式
            var account = new ProxyAccount();
            var user = new User { Name = "Tom", Password = "12345678" };
            account.Reg(user);
            #endregion

            Console.ReadKey();
        }
    }
}

运行结果：

可能有的人会发现，装饰器类和代理类很相像，功能也一模一样，仅仅是构造函数不同。那么装饰器模式和代理模式有区别吗？有些东西，形式上看起来区别很小，但实际上他们区别很大。它们在形式上确实一样，不管是装饰器类还是代理类，它们都要实现相同的接口，但是它们在运用的时候还是有区别的。

装饰器模式关注于在一个对象上动态添加方法，而代理模式关注于控制对象的访问。简单来说，使用代理模式，我们的代理类可以隐藏一个类的具体信息。var account = new ProxyAccount();仅看这段代码不看源码，不知道里面代理的是谁。

当使用代理模式的时候，我们常常是在代理类中去创建一个对象的实例： _accountService = new AccountService()。而当我们使用装饰器模式的时候，我们通常是将原始对象作为一个参数传递给装饰器的构造函数。简单来说，在使用装饰器模式的时候，我们可以明确地知道装饰的是谁，而且更重要的是，代理类里面是写死的，在编译的时候就确定了关系。而装饰器是在运行时来确定的。

2、动态代理

动态代理实现也有两种方式；

通过代码织入的方式。例如 PostSharp 第三方插件。我们知道.NET 程序最终会编译成 IL 中间语言，在编译程序的时候，PostSharp 会动态的去修改 IL，在 IL 里面添加代码，这就是代码织入的方式。
通过反射的方式实现。通过反射实现的方法非常多，也有很多实现了 AOP 的框架，例如 Unity、MVC 过滤器、Autofac 等

我们先来看看如何使用 PostSharp 实现动态代理。PostSharp 是一款收费的第三方插件。

首先新创建一个控制台应用程序，然后创建一个订单业务类：

using System;

namespace PostSharpDemo
{
    /// <summary>
    /// 订单业务类
    /// </summary>
    public class OrderBusiness
    {
        public void DoWork()
        {
            Console.WriteLine("执行订单业务");
        }
    }
}

接着在 Main 方法里面调用：

using System;

namespace PostSharpDemo
{
    class Program
    {
        static void Main(string[] args)
        {
            OrderBusiness order = new OrderBusiness();
            // 调用方法
            order.DoWork();
            Console.ReadKey();
        }
    }
}

运行结果：

这时又提出了一个新的需求，要去添加一个日志功能，记录业务的执行情况，按照以前的办法，需要定义一个日志帮助类：

using System;
using System.IO;

namespace PostSharpDemo
{
    public class LgoHelper
    {
        public static void RecoreLog(string message)
        {
            string strPath = AppDomain.CurrentDomain.BaseDirectory+"\\log.txt";
            using(StreamWriter sw=new StreamWriter(strPath,true))
            {
                sw.WriteLine(message);
                sw.Close();
            }
        }
    }
}

如果不使用 AOP，我们就需要在记录日志的地方实例化 Loghelper 对象，然后记录日志：

using System;

namespace PostSharpDemo
{
    /// <summary>
    /// 订单业务类
    /// </summary>
    public class OrderBusiness
    {
        public void DoWork()
        {
            // 记录日志
            LgoHelper.RecoreLog("执行业务前");
            Console.WriteLine("执行订单业务");
            LgoHelper.RecoreLog("执行业务后");
        }
    }
}

我们再次运行程序，查看结果：

我们看看日志内容：

这样修改可以实现记录日志的功能。但是上面的方法会修改原先已有的代码，这就违反了开闭原则。而且添加日志也不是业务需求的变动，不应该去修改业务代码。下面使用 AOP 来实现。首先安装 PostSharp，直接在 NuGet 里面搜索，然后安装即可：

然后定义一个 LogAttribute 类，继承自 OnMethodBoundaryAspect。这个 Aspect 提供了进入、退出函数等连接点方法。另外，Aspect 上必须设置 “[Serializable] ”，这与 PostSharp 内部对 Aspect 的生命周期管理有关：

using PostSharp.Aspects;
using System;

namespace PostSharpDemo
{
    [Serializable]
    [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
    public class LogAttribute: OnMethodBoundaryAspect
    {
        public string ActionName { get; set; }
        public override void OnEntry(MethodExecutionArgs eventArgs)
        {
            LgoHelper.RecoreLog(ActionName + "开始执行业务前");
        }

        public override void OnExit(MethodExecutionArgs eventArgs)
        {
            LgoHelper.RecoreLog(ActionName + "业务执行完成后");
        }
    }
}

然后 Log 特性应用到 DoWork 函数上面：

using System;

namespace PostSharpDemo
{
    /// <summary>
    /// 订单业务类
    /// </summary>
    public class OrderBusiness
    {
        [Log(ActionName ="DoWork")]
        public void DoWork()
        {
            // 记录日志
            // LgoHelper.RecoreLog("执行业务前");
            Console.WriteLine("执行订单业务");
            // LgoHelper.RecoreLog("执行业务后");
        }
    }
}

这样修改以后，只需要在方法上面添加一个特性，以前记录日志的代码就可以注释掉了，这样就不会再修改业务逻辑代码了，运行程序：

在看看日志：

这样就实现了 AOP 功能。

我们在看看使用 Remoting 来实现动态代理。

首先还是创建一个 User 实体类：

namespace DynamicProxy.Model
{
    public class User
    {
        public string Name { get; set; }
        public string Password { get; set; }
    }
}

然后创建一个接口，里面有一个注册方法：

using DynamicProxy.Model;

namespace DynamicProxy.Services
{
    public interface IAccountService
    {
        void Reg(User user);
    }
}

然后创建接口的实现类：

using DynamicProxy.Model;
using System;

namespace DynamicProxy.Services
{
    public class AccountService : MarshalByRefObject, IAccountService
    {
        public void Reg(User user)
        {
            Console.WriteLine($"{user.Name}注册成功");
        }
    }
}

然后创建一个泛型的动态代理类：

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Remoting.Proxies;

namespace DynamicProxy
{
    public class DynamicProxy<T> : RealProxy
    {
        private readonly T _target;

        // 执行之前
        public Action BeforeAction { get; set; }

        // 执行之后
        public Action AfterAction { get; set; }

        // 被代理泛型类
        public DynamicProxy(T target) : base(typeof(T))
        {
            _target = target;
        }

        // 代理类调用方法
        public override IMessage Invoke(IMessage msg)
        {
            var reqMsg = msg as IMethodCallMessage;
            var target = _target as MarshalByRefObject;

            BeforeAction();
            // 这里才真正去执行代理类里面的方法
            // target表示被代理的对象，reqMsg表示要执行的方法
            var result = RemotingServices.ExecuteMessage(target, reqMsg);
            AfterAction();
            return result;
        }

    }
}

我们看到，这个泛型动态代理类里面有两个泛型委托：BeforeAction、AfterAction。通过构造函数把代理泛型类传递进去。最后调用 Invoke 方法执行代理类的方法。

最后我们还要创建一个代理工厂类，用来创建代理对象，通过调用动态代理来创建动态代理对象：

using System;

namespace DynamicProxy
{
    /// <summary>
    /// 动态代理工厂类
    /// </summary>
    public static class ProxyFactory
    {
        public static T Create<T>(Action before, Action after)
        {
            // 实例化被代理泛型对象
            T instance = Activator.CreateInstance<T>();
            // 实例化动态代理，创建动态代理对象
            var proxy = new DynamicProxy<T>(instance) { BeforeAction = before, AfterAction = after };
            // 返回透明代理对象
            return (T)proxy.GetTransparentProxy();
        }
    }
}

我们最后在 Main 方法里面调用：

using DynamicProxy.Model;
using DynamicProxy.Services;
using System;

namespace DynamicProxy
{
    class Program
    {
        static void Main(string[] args)
        {
            // 调用动态代理工厂类创建动态代理对象，传递AccountService，并且传递两个委托
            var acount = ProxyFactory.Create<AccountService>(before:() =>
            {
                Console.WriteLine("注册之前");
            }, after:() =>
            {
                Console.WriteLine("注册之后");
            });

            User user = new User() 
            {
             Name="张三",
             Password="123456"
            };
            // 调用注册方法
            acount.Reg(user);

            Console.ReadKey();
        }
    }
}

程序运行结果：

这样就利用 Remoting 实现了动态代理。

关于越南语中 Decimal 转换错误的问题以及解决方案

wangbaochen — Thu, 10 Jun 2021 14:22:36 +0800

由于服务器上的地区和文化设置是以，作为小数，.作为数字分组。所以在越南语中转换小数时失败。

在越南语环境中可以使用以下语法：

var decimalValue = Convert.ToDecimal(stringValue, CultureInfo.InvariantCulture);

或

decimal.Parse(s, CultureInfo.InvariantCulture);

或者设置区域与语言

失败
成功

时间复杂度和空间复杂度以及空间换时间小例

wangbaochen — Fri, 04 Jun 2021 14:44:13 +0800

时间复杂度和空间复杂度

通常不同的算法虽然结果一样但是消耗资源和时间却会有很大差别，衡量不同算法之间的优劣就要用到时间复杂度和空间复杂度

时间复杂度

时间指运行算法所需要的时间，那我们运行用 C# 程序看一下运行时间不得了，但是这个性能好的电脑和性能不好的电脑时间肯定是不同的。所以有了大 O 符号表示法 T（n）=O(f(n))

下面这个 for 循环运行需要
for (int i = 0; i < n; i++) 需要一个单位时间
j = i;N 次需要 N 个单位时间
j++;也是 N 次
所以时间复杂度为 T（n）=（1+2n）* 单位时间
简化为 O（n）

for (int i = 0; i < n; i++)
{
    j = i;
    j++;
}

常见的时间复杂度量级

常数阶 O（1）

就是没有复杂循环结构不管执行多少行几万十几万行都按 O(1) 算
```
j = i;
j++;
```
线性阶 O(n)

就是上面的 for 循环消耗时间随着 N 变化而变化
```
for (int i = 0; i < n; i++)
{
    j = i;
    j++;
}
```
对数阶 O(logN)

下面的循环就按 i*2 何时=N，就是 2 的多少次方是 N，log2^N
```
int i = 1;
while(i<n)
{
    i = i * 2;
}
```

线性对数阶 O(nlogN)

就是 for 循环套 while

for(m=1; m<n; m++)
{
    i = 1;
    while(i<n)
    {
        i = i * 2;
    }
}

平方阶 O(n²)

就是双重 for 循环如果把里面一层改成 m 那么复杂度就是 O(m*n)

for (int i = 0; i < n; i++)
{
    for (int j = 0; j < n; j++)
    {
        j = i;
        j++;
    }
}

然后 for 越多就 K 次方阶 O(n^k) 这样子

空间复杂度

O(1)

就是算法执行临时空间不会随着 N 发生变化都算成一个常量
```
j = i;
j++;
```
O(n)

int[] m = new int[n] new 出来了 N 个所以是 N 下面循环并没有再开临时变量
```
int[] m = new int[n]
for(i=1; i<=n; ++i)
{
    j = i;
    j++;
}
```

空间复杂度其实和时间复杂度判断标准差不多主要是看开了多少个临时变量是否跟 N 有一定的线性关系

这都是一些简单的如果是复杂的怎么计算呢下面都计算时间复杂度为例子

T(n) = n + 29 一般说是 O(n) 因为常数项影响函数增长很小
T(n) = n^3 + n^2 + 29 一般说为 O(n3)，n3 的增长速度是远超 n^2 的，同时 n^2 的增长速度是远超 n 的，所以有了高次项可以忽略低次项
T(n) = 3n^3 一般说为 O(n^3) 因为阶数比乘数影响增长速度最显著我们通常忽略比如这个时间复杂度为 max(O(n^2), O(n)) 及 O（n^2）

 void aFunc(int n) {
    // 第一部分时间复杂度为 O(n^2)
    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            printf("Hello, World!\n");//时间复杂度为O(1)
        }
    }

    // 第二部分时间复杂度为 O(n)
    for (int j = 0; j < n; j++)
    {
        printf("Hello, World!\n");
    }
}

下面这个 T（0）=T（1）=1
T（n）=T(n-1)+T(n-2)+1 加一因为加法算一次执行
会发现这就是个裴波那契数列

long aFunc(int n) {
    if (n <= 1) {
        return 1;
    } else {
        return aFunc(n - 1) + aFunc(n - 2);
    }
}

就是每多一层计算就要一次单位时间
就按第五层来算就是 2^3+1=7 次计算
N 才需要 2^(n-2)+1 次计算
那么时间复杂度就是 O（2(n-2)+1）常数项忽略就是 O（2n）

空间换时间案例

在执行多次循环时，可以通过键值对的方式替换循环。达到空间换时间，提高运行效率。

#region 获取两个数组中名称相同的值的和

#region 写法一

DateTime time1 = DateTime.Now;
int sum1 = 0;
int num1 = 0;
foreach (var class1 in class1s)
{
    foreach (var class2 in class2s)
    {
        if (class1.Name == class2.Name)
        {
            sum1 += class1.Value + class2.Value;
        }
        num1 += 1;
    }
}
DateTime time2 = DateTime.Now;
Console.WriteLine($"写法一：总和为{sum1}，循环{num1}次，耗时：{(time2 - time1).TotalMilliseconds}毫秒");

#endregion

#region 写法二

DateTime time3 = DateTime.Now;
int sum2 = 0;
int num2 = 0;
foreach (var class1 in class1s)
{
    foreach (var class2 in class2s)
    {
        num2 += 1;
        if (class1.Name == class2.Name)
        {
            sum2 += class1.Value + class2.Value;
            break;
        }
    }
}
DateTime time4 = DateTime.Now;
Console.WriteLine($"写法二：总和为{sum2}，循环{num2}次，耗时：{(time4 - time3).TotalMilliseconds}毫秒");

#endregion

#region 写法三

DateTime time5 = DateTime.Now;
int num3 = 0;
Dictionary<string, int> pairs = new Dictionary<string, int>();
foreach (var class2 in class2s)
{
    pairs.Add(class2.Name, class2.Value);
    num3 += 1;
}

int sum3 = 0;
foreach (var class1 in class1s)
{
    if (pairs.ContainsKey(class1.Name))
        sum3 += class1.Value + pairs[class1.Name];
    num3 += 1;
}
DateTime time6 = DateTime.Now;
Console.WriteLine($"写法三：总和为{sum3}，循环{num3}次，耗时：{(time6 - time5).TotalMilliseconds}毫秒");
Console.ReadLine();

#endregion

#endregion

源码地址：https://git.xxb.lttc.cn/wangbc/Demo/src/master/ONDemo

报表平台

wangbaochen — Wed, 02 Jun 2021 15:25:32 +0800

报表平台

为了满足日益增加的需求，在不改变现有报表的基础上进行升级。

报表创建工具

报表定义

增加以下功能：

是否手动选列

勾选之后用户可以在方案管理界面中手动选择所需要获取的列。
此属性需要配合报表配置信息和数据源一起使用。
配置信息中需要配置查询字段，数据源中需要将列字段替换为关键字 {ColumnString}

是否分页、默认每页行数

现在平面报表中增加分页功能，获取大量数据时，分次获取，减少等待时间。
是否分页勾选之后，默认每页行数必须填写

平面报表展示模式

在平面报表行双击可以将整行展示在一个 Group 中，方便多列时查看，第一次双击初始化比较慢。

行：默认选择，以行的形式显示
浮动表格：双击当前行，在当前行附近展示浮动窗口。
内嵌表格：双击当前行，在当前行下展示嵌入的窗口。
无行内嵌表格：双击当前行，隐藏当前行，在当前行位置显示嵌入的窗口。

是否显示自由报表

根据用户需求展示设计的界面，方便用户查看。

是否显示电子表格

为了满足用户数据分析需求，添加一个基础的 EXCEL 电子表格，方便用户自己分析数据。
由于电子表格控件比较多，加载会慢。

是否显示仪表盘

为了满足用户数据展示需求，添加仪表盘报表，方便用户查看数据。

报表数据源

为了配合报表功能，现添加如下关键字：

{ColumnString} :列信息，勾选手动选列时使用，还需配合列配置信息使用。
{FilterString} :分页时使用，过滤或排序时使用此关键字。
{GroupString} :，分组关键字，手动选列时使用，还需配合列配置信息使用，转译为 group by xxx,xxx
{SortString} :排序关键字，手动选列时使用，还需配合列配置信息使用，转译为 order by xxx,xxx
{PaginationString} :分页时使用，转义为 offset pageIndex row fetch next pageSize row only

报表配置信息

在列配置信息中添加一下字段来满足报表需求：

查询字段：配合列信息关键字使用，根据用户选择列拼接到 SQL 语句中。
分组字段：配合分组关键字使用，根据用户选择列拼接到 SQL 语句中。
排序字段：配合排序关键字使用，根据用户选择列拼接到 SQL 语句中。
列过滤模式：根据配置的不同在平面报表列过滤时，显示不同的配置。
- Excel：
- List:
- CheckedList:
- Date:
- DateSmart:
- DateAlt:
是否必取列：勾选之后，此列在用户手动选列时，不可选择，此列必取。

报表

方案管理

根据需求添加选择报表和选择列 Group.

选择报表：展示报表设计中选择的报表类型，用户根据自身需求勾选需要实例化的报表。防止报表过多加载过慢。
列选择：用户可以根据自身需要勾选获取的列，以及设置列顺序。

数据库直连

现在报表支持数据库直连，设置方式和模块设置方式相同。

两处都需要勾选

Docker 入门，万字详解

wangbaochen — Wed, 14 Apr 2021 13:42:16 +0800

容器简介

什么是 Linux 容器

Linux 容器是与系统其他部分隔离开的一系列进程，从另一个镜像运行，并由该镜像提供支持进程所需的全部文件。

容器提供的镜像包含了应用的所有依赖项，因而在从开发到测试再到生产的整个过程中，它都具有可移植性和一致性。

更加详细地来说，请您假定您在开发一个应用。您使用的是一台笔记本电脑，而且您的开发环境具有特定的配置。其他开发人员身处的环境配置可能稍有不同。您正在开发的应用依赖于您当前的配置，还要依赖于某些特定文件。

与此同时，您的企业还拥有标准化的测试和生产环境，且具有自身的配置和一系列支持文件。

您希望尽可能多在本地模拟这些环境，而不产生重新创建服务器环境的开销。

因此，您要如何确保应用能够在这些环境中运行和通过质量检测，并且在部署过程中不出现令人头疼的问题，也无需重新编写代码和进行故障修复？答案就是使用容器。

容器可以确保您的应用拥有必需的配置和文件，使得这些应用能够在从开发到测试、再到生产的整个流程中顺利运行，而不出现任何不良问题。这样可以避免危机，做到皆大欢喜。

虽然这只是简化的示例，但在需要很高的可移植性、可配置性和隔离的情况下，我们可以利用 Linux 容器通过很多方式解决难题。

无论基础架构是在企业内部还是在云端，或者混合使用两者，容器都能满足您的需求。

容器不就是虚拟化吗

是，但也不竟然。我们用一种简单方式来思考一下：

虚拟化使得许多操作系统可同时在单个系统上运行。

容器则可共享同一个操作系统内核，将应用进程与系统其他部分隔离开。

这意味着什么？首先，让多个操作系统在单个虚拟机监控程序上运行以实现虚拟化，并不能达成和使用容器同等的轻量级效果。

事实上，在仅拥有容量有限的有限资源时，您需要能够可以进行密集部署的轻量级应用。

Linux 容器可从单个操作系统运行，在所有容器中共享该操作系统，因此应用和服务能够保持轻量级，并行快速运行。

什么是 Docker？

“Docker” 一词指代多种事物，包括开源社区项目、开源项目使用的工具、主导支持此类项目的公司 Docker Inc. 以及该公司官方支持的工具。技术产品和公司使用同一名称，的确让人有点困惑。

我们来简单说明一下：

🎍 IT 软件中所说的 “Docker” ，是指容器化技术，用于支持创建和使用 Linux 容器。
🎍 开源 Docker 社区致力于改进这类技术，并免费提供给所有用户，使之获益。
🎍 Docker Inc. 公司凭借 Docker 社区产品起家，它主要负责提升社区版本的安全性，并将改进后的版本与更广泛的技术社区分享。此外，它还专门对这些技术产品进行完善和安全固化，以服务于企业客户。

借助 Docker ，您可将容器当做重量轻、模块化的虚拟机使用。同时，您还将获得高度的灵活性，从而实现对容器的高效创建、部署及复制，并能将其从一个环境顺利迁移至另一个环境。

Docker 如何工作？

Docker 技术使用 Linux 内核和内核功能（例如 Cgroups 和 namespaces）来分隔进程，以便各进程相互独立运行。

这种独立性正是采用容器的目的所在；它可以独立运行多种进程、多个应用程序，更加充分地发挥基础设施的作用，同时保持各个独立系统的安全性。

容器工具（包括 Docker）可提供基于镜像的部署模式。这使得它能够轻松跨多种环境，与其依赖程序共享应用或服务组。Docker 还可在这一容器环境中自动部署应用程序（或者合并多种流程，以构建单个应用程序）。

此外，由于这些工具基于 Linux 容器构建，使得 Docker 既易于使用，又别具一格 —— 它可为用户提供前所未有的高度应用程访问权限、快速部署以及版本控制和分发能力。

Docker 技术是否与传统的 Linux 容器相同？

否。Docker 技术最初是基于 LXC 技术构建（大多数人都会将这一技术与 “传统的” Linux 容器联系在一起），但后来它逐渐摆脱了对这种技术的依赖。

就轻量级虚拟化这一功能来看，LXC 非常有用，但它无法提供出色的开发人员或用户体验。除了运行容器之外，Docker 技术还具备其他多项功能，包括简化用于构建容器、传输镜像以及控制镜像版本的流程。

传统的 Linux 容器使用 init 系统来管理多种进程。这意味着，所有应用程序都作为一个整体运行。与此相反，Docker 技术鼓励应用程序各自独立运行其进程，并提供相应工具以实现这一功能。这种精细化运作模式自有其优势。

docker 的目标

docker 的主要目标是 "Build,Ship and Run any App,Angwhere" 构建，运输，处处运行

构建： 做一个 docker 镜像
运输： docker pull
运行： 启动一个容器

每一个容器，他都有自己的文件系统 rootfs.

安装 Docker

环境说明

# 需要两台几点进行安装
[root@docker01 ~]# cat /etc/redhat-release 
CentOS Linux release 7.2.1511 (Core) 
[root@docker01 ~]# uname  -r 
3.10.0-327.el7.x86_64
[root@docker01 ~]# hostname -I
10.0.0.100 172.16.1.100 
[root@docker02 ~]# hostname -I
10.0.0.101 172.16.1.101

在两个节点上都进行操作

wget -O /etc/yum.repos.d/docker-ce.repo https://mirrors.ustc.edu.cn/docker-ce/linux/centos/docker-ce.repo
sed -i 's#download.docker.com#mirrors.ustc.edu.cn/docker-ce#g' /etc/yum.repos.d/docker-ce.repo
yum install docker-ce -y

修改在 docker01 配置：

# 修改启动文件，监听远程端口
vim /usr/lib/systemd/system/docker.service
ExecStart=/usr/bin/dockerd -H unix:///var/run/docker.sock -H tcp://10.0.0.100:2375
systemctl daemon-reload
systemctl enable docker.service 
systemctl restart docker.service
# ps -ef检查进行，是否启动

在 docker02 测试

[root@docker02 ~]# docker -H 10.0.0.100 info
Containers: 0
 Running: 0
 Paused: 0
 Stopped: 0
Images: 0
Server Version: 17.12.0-ce
Storage Driver: devicemapper
···

Docker 基础命令操作

查看 docker 相关信息

[root@docker01 ~]#  docker version  
Client:
 Version:    17.12.0-ce
 API version:    1.35
 Go version:    go1.9.2
 Git commit:    c97c6d6
 Built:    Wed Dec 27 20:10:14 2017
 OS/Arch:    linux/amd64
Server:
 Engine:
  Version:    17.12.0-ce
  API version:    1.35 (minimum version 1.12)
  Go version:    go1.9.2
  Git commit:    c97c6d6
  Built:    Wed Dec 27 20:12:46 2017
  OS/Arch:    linux/amd64
  Experimental:    false

配置 docker 镜像加速

vi /etc/docker/daemon.json
{
  "registry-mirrors": ["https://registry.docker-cn.com"]
}

启动第一个容器

[root@docker01 ~]# docker run -d -p 80:80 nginx
Unable to find image 'nginx:latest' locally
latest: Pulling from library/nginx
e7bb522d92ff: Pull complete 
6edc05228666: Pull complete 
cd866a17e81f: Pull complete 
Digest: sha256:285b49d42c703fdf257d1e2422765c4ba9d3e37768d6ea83d7fe2043dad6e63d
Status: Downloaded newer image for nginx:latest
8d8f81da12b5c10af6ba1a5d07f4abc041cb95b01f3d632c3d638922800b0b4d
# 容器启动后，在浏览器进行访问测试

参数说明

Docker 镜像生命周期

docker 镜像相关操作

搜索官方仓库镜像

[root@docker01 ~]#  docker search centos
NAME                      DESCRIPTION                    STARS    OFFICIAL               AUTOMATED
centos                    The official build of CentOS.  3992     [OK]      
ansible/centos7-ansible   Ansible on Centos7             105                              [OK]

列表说明

获取镜像

根据镜像名称拉取镜像

[root@docker01 ~]# docker pull centos
Using default tag: latest
latest: Pulling from library/centos
af4b0a2388c6: Downloading  34.65MB/73.67MB

查看当前主机镜像列表

[root@docker01 ~]# docker image list 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
centos              latest              ff426288ea90        3 weeks ago         207MB
nginx               latest              3f8a4339aadd        5 weeks ago         108MB

拉第三方镜像方法

docker pull index.tenxcloud.com/tenxcloud/httpd

导出镜像

[root@docker01 ~]# docker image list 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
centos              latest              ff426288ea90        3 weeks ago         207MB
nginx               latest              3f8a4339aadd        5 weeks ago         108MB
# 导出
[root@docker01 ~]# docker image save centos > docker-centos.tar.gz

#### 删除镜像

[root@docker01 ~]# docker image rm centos:latest
[root@docker01 ~]# docker image list 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
nginx               latest              3f8a4339aadd        5 weeks ago         108MB

#### 导入镜像

[root@docker01 ~]# docker image load -i docker-centos.tar.gz  
e15afa4858b6: Loading layer  215.8MB/215.8MB
Loaded image: centos:latest
[root@docker01 ~]# docker image list 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
centos              latest              ff426288ea90        3 weeks ago         207MB
nginx               latest              3f8a4339aadd        5 weeks ago         108MB

#### 查看镜像的详细信息

[root@docker01 ~]# docker image inspect centos

容器的日常管理

#### 容器的起/停

最简单的运行一个容器

[root@docker01 ~]# docker run nginx

创建容器，两步走（不常用）

[root@docker01 ~]# docker create centos:latest  /bin/bash
bb7f32368ecf0492adb59e20032ab2e6cf6a563a0e6751e58930ee5f7aaef204
[root@docker01 ~]# docker start stupefied_nobel
stupefied_nobel

快速启动容器方法

[root@docker01 ~]# docker run  centos:latest  /usr/bin/sleep 20;

容器内的第一个进程必须一直处于运行的状态，否则这个容器，就会处于退出状态！

查看正在运行的容器

[root@docker01 ~]# docker container ls
    或
[root@docker01 ~]# docker ps 
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
8708e93fd767        nginx               "nginx -g 'daemon of…"   6 seconds ago       Up 4 seconds        80/tcp              keen_lewi

查看你容器详细信息/ip

[root@docker01 ~]# docker container  inspect  容器名称/id

查看你所有容器（包括未运行的）

[root@docker01 ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                      PORTS               NAMES
8708e93fd767        nginx               "nginx -g 'daemon of…"   4 minutes ago       Exited (0) 59 seconds ago                       keen_lewin
f9f3e6af7508        nginx               "nginx -g 'daemon of…"   5 minutes ago       Exited (0) 5 minutes ago                        optimistic_haibt
8d8f81da12b5        nginx               "nginx -g 'daemon of…"   3 hours ago         Exited (0) 3 hours ago                          lucid_bohr

停止容器

[root@docker01 ~]# docker stop 容器名称/id 
或
[root@docker01 ~]# docker container  kill  容器名称/id

进入容器方法

启动时进去方法

[root@docker01 ~]# docker run -it #参数：-it 可交互终端
[root@docker01 ~]# docker run -it nginx:latest  /bin/bash
root@79241093859e:/#

退出/离开容器

ctrl+p & ctrl+q

启动后进入容器的方法

启动一个 docker

[root@docker01 ~]# docker run -it centos:latest 
[root@1bf0f43c4d2f /]# ps -ef 
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 15:47 pts/0    00:00:00 /bin/bash
root         13      1  0 15:47 pts/0    00:00:00 ps -ef

attach 进入容器，使用 pts/0 ，会让所用通过此方法进如放入用户看到同样的操作。

[root@docker01 ~]# docker attach 1bf0f43c4d2f
[root@1bf0f43c4d2f /]# ps -ef 
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 15:47 pts/0    00:00:00 /bin/bash
root         14      1  0 15:49 pts/0    00:00:00 ps -ef

自命名启动一个容器 --name

[root@docker01 ~]# docker attach 1bf0f43c4d2f
[root@1bf0f43c4d2f /]# ps -ef 
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 15:47 pts/0    00:00:00 /bin/bash
root         14      1  0 15:49 pts/0    00:00:00 ps -ef

exec 进入容器方法（推荐使用）

[root@docker01 ~]# docker exec -it clsn1  /bin/bash 
[root@b20fa75b4b40 /]# 重新分配一个终端
[root@b20fa75b4b40 /]# ps -ef 
UID         PID   PPID  C STIME TTY          TIME CMD
root          1      0  0 16:11 pts/0    00:00:00 /bin/bash
root         13      0  0 16:14 pts/1    00:00:00 /bin/bash
root         26     13  0 16:14 pts/1    00:00:00 ps -ef

删除所有容器

[root@docker01 ~]# docker rm -f  `docker ps -a -q`
# -f 强制删除

启动时进行端口映射

-p 参数端口映射

[root@docker01 ~]# docker run -d -p 8888:80  nginx:latest 
287bec5c60263166c03e1fc5b0b8262fe76507be3dfae4ce5cd2ee2d1e8a89a9

不同指定映射方法

随机映射

docker run -P （大P）# 需要镜像支持

Docker 数据卷的管理

挂载时创建卷

挂载卷

[root@docker01 ~]# docker run -d -p 80:80 -v /data:/usr/share/nginx/html nginx:latest
079786c1e297b5c5031e7a841160c74e91d4ad06516505043c60dbb78a259d09

容器内站点目录: /usr/share/nginx/html

在宿主机写入数据，查看

[root@docker01 ~]# echo "http://www.nmtui.com" >/data/index.html
[root@docker01 ~]# curl 10.0.0.100
http://www.nmtui.com

设置共享卷，使用同一个卷启动一个新的容器

[root@docker01 ~]# docker run -d -p 8080:80 -v /data:/usr/share/nginx/html nginx:latest 
351f0bd78d273604bd0971b186979aa0f3cbf45247274493d2490527babb4e42
[root@docker01 ~]# curl 10.0.0.100:8080
http://www.nmtui.com

查看卷列表

[root@docker01 ~]# docker volume ls
DRIVER              VOLUME NAME

创建卷后挂载

创建一个卷

[root@docker01 ~]# docker volume create 
f3b95f7bd17da220e63d4e70850b8d7fb3e20f8ad02043423a39fdd072b83521
[root@docker01 ~]# docker volume ls 
DRIVER              VOLUME NAME
local               f3b95f7bd17da220e63d4e70850b8d7fb3e20f8ad02043423a39fdd072b83521

指定卷名

[root@docker01 ~]# docker volume ls 
DRIVER              VOLUME NAME
local               clsn
local               f3b95f7bd17da220e63d4e70850b8d7fb3e20f8ad02043423a39fdd072b83521

查看卷路径

[root@docker01 ~]# docker volume inspect clsn 
[
    {
        "CreatedAt": "2018-02-01T00:39:25+08:00",
        "Driver": "local",
        "Labels": {},
        "Mountpoint": "/var/lib/docker/volumes/clsn/_data",
        "Name": "clsn",
        "Options": {},
        "Scope": "local"
    }
]

使用卷创建

[root@docker01 ~]# docker run -d -p 9000:80 -v clsn:/usr/share/nginx/html nginx:latest 
1434559cff996162da7ce71820ed8f5937fb7c02113bbc84e965845c219d3503
# 宿主机测试
[root@docker01 ~]# echo 'blog.nmtui.com' >/var/lib/docker/volumes/clsn/_data/index.html 
[root@docker01 ~]# curl 10.0.0.100:9000
blog.nmtui.com

设置卷

[root@docker01 ~]# docker run  -d  -P  --volumes-from 079786c1e297 nginx:latest 
b54b9c9930b417ab3257c6e4a8280b54fae57043c0b76b9dc60b4788e92369fb

查看使用的端口

[root@docker01 ~]# netstat -lntup 
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name    
tcp        0      0 0.0.0.0:22              0.0.0.0:*               LISTEN      1400/sshd           
tcp        0      0 10.0.0.100:2375         0.0.0.0:*               LISTEN      26218/dockerd       
tcp6       0      0 :::9000                 :::*                    LISTEN      32015/docker-proxy  
tcp6       0      0 :::8080                 :::*                    LISTEN      31853/docker-proxy  
tcp6       0      0 :::80                   :::*                    LISTEN      31752/docker-proxy  
tcp6       0      0 :::22                   :::*                    LISTEN      1400/sshd           
tcp6       0      0 :::32769                :::*                    LISTEN      32300/docker-proxy  
[root@docker01 ~]# curl 10.0.0.100:32769
http://www.nmtui.com

手动将容器保存为镜像

本次是基于 docker 官方 centos 6.8 镜像创建

官方镜像列表：https://hub.docker.com/explore/

启动一个 centos6.8 的镜像

[root@docker01 ~]# docker pull  centos:6.8
[root@docker01 ~]# docker run -it -p 1022:22 centos:6.8  /bin/bash
# 在容器种安装sshd服务，并修改系统密码
[root@582051b2b92b ~]# yum install  openssh-server -y 
[root@582051b2b92b ~]# echo "root:123456" |chpasswd
[root@582051b2b92b ~]#  /etc/init.d/sshd start

启动完成后镜像 ssh 连接测试

将容器提交为镜像

[root@docker01 ~]# docker commit brave_mcclintock  centos6-ssh

使用新的镜像启动容器

[root@docker01 ~]# docker run -d  -p 1122:22  centos6-ssh:latest  /usr/sbin/sshd -D 
5b8161fda2a9f2c39c196c67e2eb9274977e7723fe51c4f08a0190217ae93094

在容器安装 httpd 服务

[root@5b8161fda2a9 /]#  yum install httpd -y

编写启动脚本脚本

[root@5b8161fda2a9 /]# cat  init.sh 
#!/bin/bash 
/etc/init.d/httpd start 
/usr/sbin/sshd -D
[root@5b8161fda2a9 /]# chmod +x init.sh 
# 注意执行权限

再次提交为新的镜像

[root@docker01 ~]# docker commit  5b8161fda2a9 centos6-httpd 
sha256:705d67a786cac040800b8485cf046fd57b1828b805c515377fc3e9cea3a481c1

启动镜像，做好端口映射。并在浏览器中测试访问

[root@docker01 ~]# docker run -d -p 1222:22 -p 80:80  centos6-httpd /init.sh 
46fa6a06644e31701dc019fb3a8c3b6ef008d4c2c10d46662a97664f838d8c2c

Dockerfile 自动构建 docker 镜像

#### Dockerfile 指令集

dockerfile 主要组成部分：

基础镜像信息 FROM centos:6.8
制作镜像操作指令 RUN yum insatll openssh-server -y
容器启动时执行指令 CMD ["/bin/bash"]

dockerfile 常用指令：

FROM 这个镜像的妈妈是谁？（指定基础镜像）
MAINTAINER 告诉别人，谁负责养它？（指定维护者信息，可以没有）
RUN 你想让它干啥（在命令前面加上 RUN 即可）
ADD 给它点创业资金（COPY 文件，会自动解压）
WORKDIR 我是 cd，今天刚化了妆（设置当前工作目录）
VOLUME 给它一个存放行李的地方（设置卷，挂载主机目录）
EXPOSE 它要打开的门是啥（指定对外的端口）
CMD 奔跑吧，兄弟！（指定容器启动后的要干的事情）

dockerfile 其他指令：

COPY 复制文件
ENV 环境变量
ENTRYPOINT 容器启动后执行的命令

#### 创建一个 Dockerfile

创建第一个 Dockerfile 文件

# 创建目录
[root@docker01 base]# cd /opt/base
# 创建Dcokerfile文件，注意大小写
[root@docker01 base]# vim Dockerfile
FROM centos:6.8
RUN yum install openssh-server -y 
RUN echo "root:123456" |chpasswd
RUN /etc/init.d/sshd start 
CMD ["/usr/sbin/sshd","-D"]

构建 docker 镜像

[root@docker01 base]# docker image build  -t centos6.8-ssh . 
-t 为镜像标签打标签  . 表示当前路径

使用自构建的镜像启动

[root@docker01 base]# docker run  -d -p 2022:22 centos6.8-ssh-b 
dc3027d3c15dac881e8e2aeff80724216f3ac725f142daa66484f7cb5d074e7a

#### 使用 Dcokerfile 安装 kodexplorer

Dockerfile 文件内容

FROM centos:6.8
RUN yum install wget unzip php php-gd php-mbstring -y && yum clean all
# 设置工作目录，之后的操作都在这个目录中
WORKDIR /var/www/html/
RUN wget -c http://static.kodcloud.com/update/download/kodexplorer4.25.zip
RUN unzip kodexplorer4.25.zip && rm -f kodexplorer4.25.zip
RUN chown -R apache.apache .
CMD ["/usr/sbin/apachectl","-D","FOREGROUND"]

更多的 Dockerfile 可以参考官方方法。

Docker 中的镜像分层

Docker 支持通过扩展现有镜像，创建新的镜像。实际上，Docker Hub 中 99% 的镜像都是通过在 base 镜像中安装和配置需要的软件构建出来的。

从上图可以看到，新镜像是从 base 镜像一层一层叠加生成的。每安装一个软件，就在现有镜像的基础上增加一层。

### Docker 镜像为什么分层

镜像分层最大的一个好处就是共享资源。

比如说有多个镜像都从相同的 base 镜像构建而来，那么 Docker Host 只需在磁盘上保存一份 base 镜像；同时内存中也只需加载一份 base 镜像，就可以为所有容器服务了。而且镜像的每一层都可以被共享。

如果多个容器共享一份基础镜像，当某个容器修改了基础镜像的内容，比如 /etc 下的文件，这时其他容器的 /etc 是不会被修改的，修改只会被限制在单个容器内。这就是容器 Copy-on-Write 特性。

可写的容器层

当容器启动时，一个新的可写层被加载到镜像的顶部。这一层通常被称作 “容器层”，“容器层” 之下的都叫 “镜像层”。

所有对容器的改动 - 无论添加、删除、还是修改文件都只会发生在容器层中。只有容器层是可写的，容器层下面的所有镜像层都是只读的。

容器层的细节说明

镜像层数量可能会很多，所有镜像层会联合在一起组成一个统一的文件系统。如果不同层中有一个相同路径的文件，比如 /a，上层的 /a 会覆盖下层的 /a，也就是说用户只能访问到上层中的文件 /a。在容器层中，用户看到的是一个叠加之后的文件系统。

文件操作：

只有当需要修改时才复制一份数据，这种特性被称作 Copy-on-Write。可见，容器层保存的是镜像变化的部分，不会对镜像本身进行任何修改。

这样就解释了我们前面提出的问题：容器层记录对镜像的修改，所有镜像层都是只读的，不会被容器修改，所以镜像可以被多个容器共享。

使用 docker 运行 zabbix-server

容器间的互联

在运行 zabbix 之前务必要了解容器间互联的方法

# 创建一个nginx容器
docker run -d -p 80:80 nginx
# 创建容器，做link，并进入容器中
docker run -it --link quirky_brown:web01 centos-ssh /bin/bash
# 在容器中访问nginx容器可以ping通
ping web01

命令执行过程

# 启动apache容器
[root@docker01 ~]# docker run -d httpd:2.4  
3f1f7fc554720424327286bd2b04aeab1b084a3fb011a785b0deab6a34e56955
^[[A[root@docker01 docker ps -a
CONTAINER ID        IMAGE               COMMAND              CREATED             STATUS              PORTS               NAMES
3f1f7fc55472        httpd:2.4           "httpd-foreground"   6 seconds ago       Up 5 seconds        80/tcp              determined_clarke
# 拉取一个busybox 镜像
[root@docker01 ~]# docker pull busybox 
# 启动容器
[root@docker01 ~]# docker run -it  --link determined_clarke:web busybox:latest   /bin/sh 
/ # 
# 使用新的容器访问最初的web容器
/ # ping web 
PING web (172.17.0.2): 56 data bytes
64 bytes from 172.17.0.2: seq=0 ttl=64 time=0.058 ms
^C
--- web ping statistics ---
1 packets transmitted, 1 packets received, 0% packet loss
round-trip min/avg/max = 0.058/0.058/0.058 ms

启动 zabbix 容器

1、启动一个 mysql 的容器

docker run --name mysql-server -t \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      -d mysql:5.7 \
      --character-set-server=utf8 --collation-server=utf8_bin

2、启动 java-gateway 容器监控 java 服务

docker run --name zabbix-java-gateway -t \
      -d zabbix/zabbix-java-gateway:latest

3、启动 zabbix-mysql 容器使用 link 连接 mysql 与 java-gateway。

docker run --name zabbix-server-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      -e ZBX_JAVAGATEWAY="zabbix-java-gateway" \
      --link mysql-server:mysql \
      --link zabbix-java-gateway:zabbix-java-gateway \
      -p 10051:10051 \
      -d zabbix/zabbix-server-mysql:latest

4、启动 zabbix web 显示，使用 link 连接 zabbix-mysql 与 mysql。

docker run --name zabbix-web-nginx-mysql -t \
      -e DB_SERVER_HOST="mysql-server" \
      -e MYSQL_DATABASE="zabbix" \
      -e MYSQL_USER="zabbix" \
      -e MYSQL_PASSWORD="zabbix_pwd" \
      -e MYSQL_ROOT_PASSWORD="root_pwd" \
      --link mysql-server:mysql \
      --link zabbix-server-mysql:zabbix-server \
      -p 80:80 \
      -d zabbix/zabbix-web-nginx-mysql:latest

关于 zabbix API

关于 zabbix API 可以参考官方文档，获取 token 方法

# 获取token
[root@docker02 ~]# curl -s -X POST -H 'Content-Type:application/json' -d '
{
"jsonrpc": "2.0",
"method": "user.login",
"params": {
"user": "Admin",
"password": "zabbix"
},
"id": 1
}' http://10.0.0.100/api_jsonrpc.php
{"jsonrpc":"2.0","result":"d3be707f9e866ec5d0d1c242292cbebd","id":1}

docker 仓库（registry）

创建一个普通仓库

1、创建仓库

docker run -d -p 5000:5000 --restart=always --name registry -v /opt/myregistry:/var/lib/registry  registry

2、修改配置文件，使之支持 http

[root@docker01 ~]# cat  /etc/docker/daemon.json 
{
  "registry-mirrors": ["https://registry.docker-cn.com"],
  "insecure-registries": ["10.0.0.100:5000"]
}

重启 docker 让修改生效

[root@docker01 ~]# systemctl restart  docker.service

3、修改镜像标签

[root@docker01 ~]# docker tag  busybox:latest  10.0.0.100:5000/clsn/busybox:1.0
[root@docker01 ~]# docker images
REPOSITORY                      TAG                 IMAGE ID            CREATED             SIZE
centos6-ssh                     latest              3c2b1e57a0f5        18 hours ago        393MB
httpd                           2.4                 2e202f453940        6 days ago          179MB
10.0.0.100:5000/clsn/busybox    1.0                 5b0d59026729        8 days ago          1.15MB

4、将新打标签的镜像上传镜像到仓库

[root@docker01 ~]# docker push   10.0.0.100:5000/clsn/busybox

带 basic 认证的仓库

1、安装加密工具

[root@docker01 clsn]# yum install httpd-tools  -y

2、设置认证密码

mkdir /opt/registry-var/auth/ -p
htpasswd  -Bbn clsn 123456  > /opt/registry-var/auth/htpasswd

3、启动容器，在启动时传入认证参数

docker run -d -p 5000:5000 -v /opt/registry-var/auth/:/auth/ -e "REGISTRY_AUTH=htpasswd" -e "REGISTRY_AUTH_HTPASSWD_REALM=Registry Realm" -e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd registry

4、使用验证用户测试

# 登陆用户
[root@docker01 ~]# docker login 10.0.0.100:5000 
Username: clsn  
Password: 123456
Login Succeeded
# 推送镜像到仓库
[root@docker01 ~]# docker push 10.0.0.100:5000/clsn/busybox 
The push refers to repository [10.0.0.100:5000/clsn/busybox]
4febd3792a1f: Pushed 
1.0: digest: sha256:4cee1979ba0bf7db9fc5d28fb7b798ca69ae95a47c5fecf46327720df4ff352d size: 527
#认证文件的保存位置
[root@docker01 ~]# cat .docker/config.json 
{
    "auths": {
        "10.0.0.100:5000": {
            "auth": "Y2xzbjoxMjM0NTY="
        },
        "https://index.docker.io/v1/": {
            "auth": "Y2xzbjpIenNAMTk5Ng=="
        }
    },
    "HttpHeaders": {
        "User-Agent": "Docker-Client/17.12.0-ce (linux)"
    }
}

至此，一个简单的 docker 镜像仓库搭建完成

docker-compose 编排工具

安装 docker-compose

# 下载pip软件
yum install -y python2-pip
# 下载 docker-compose
pip install docker-compose

国内开启 pip 下载加速：https://mirrors.aliyun.com/help/pypi

mkdir ~/.pip/
cat > ~/.pip/pip.conf <<'EOF'
[global]
index-url = https://mirrors.aliyun.com/pypi/simple/
[install]
trusted-host=mirrors.aliyun.com
EOF

编排启动镜像

1、创建文件目录

[root@docker01 ~]# mkdir /opt/my_wordpress/
[root@docker01 ~]# cd /opt/my_wordpress/

2、编写编排文件

[root@docker01 my_wordpress]# vim docker-compose.yml
version: '3'
services:
   db:
     image: mysql:5.7
     volumes:
       - /data/db_data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: wordpress
   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     volumes:
       - /data/web_data:/var/www/html
     ports: 
       - "8000:80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: wordpress

3、启动

[root@docker01 my_wordpress]# docker-compose up
　　#启动方法：docker-compose up
　　#后台启动方法：docker-compose up -d

4、浏览器上访问 http://10.0.0.100:8000，进行 wordpress 的安装即可

haproxy 代理后端 docker 容器

1、修改编排脚本

[root@docker01 my_wordpress]# cat docker-compose.yml 
version: '3'
services:
   db:
     image: mysql:5.7
     volumes:
       - /data/db_data:/var/lib/mysql
     restart: always
     environment:
       MYSQL_ROOT_PASSWORD: somewordpress
       MYSQL_DATABASE: wordpress
       MYSQL_USER: wordpress
       MYSQL_PASSWORD: wordpress
   wordpress:
     depends_on:
       - db
     image: wordpress:latest
     volumes:
       - /data/web_data:/var/www/html
     ports: 
       - "80"
     restart: always
     environment:
       WORDPRESS_DB_HOST: db:3306
       WORDPRESS_DB_USER: wordpress
       WORDPRESS_DB_PASSWORD: wordpress

2、同时启动两台 wordpress

[root@docker01 my_wordpress]# docker-compose scale wordpress=2 
WARNING: The scale command is deprecated. Use the up command with the --scale flag instead.
Starting mywordpress_wordpress_1 ... done
Creating mywordpress_wordpress_2 ... done

3、安装 haproxy

[root@docker01 ~]# yum install haproxy -y

4、修改 haproxy 配置文件

[root@docker01 ~]#cp /etc/haproxy/haproxy.cfg{,.bak}
[root@docker01 ~]# vim /etc/haproxy/haproxy.cfg
global
    log         127.0.0.1 local2
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    maxconn     4000
    user        haproxy
    group       haproxy
    daemon
    stats socket /var/lib/haproxy/stats level admin  #支持命令行控制
defaults
    mode                    http
    log                     global
    option                  httplog
    option                  dontlognull
    option http-server-close
    option forwardfor       except 127.0.0.0/8
    option                  redispatch
    retries                 3
    timeout http-request    10s
    timeout queue           1m
    timeout connect         10s
    timeout client          1m
    timeout server          1m
    timeout http-keep-alive 10s
    timeout check           10s
    maxconn                 3000
listen stats
    mode http
    bind 0.0.0.0:8888
    stats enable
    stats uri     /haproxy-status 
    stats auth    admin:123456
frontend frontend_www_example_com
    bind 10.0.0.100:8000
    mode http
    option httplog
    log global
    default_backend backend_www_example_com
backend backend_www_example_com
    option forwardfor header X-REAL-IP
    option httpchk HEAD / HTTP/1.0
    balance roundrobin
    server web-node1  10.0.0.100:32768 check inter 2000 rise 30 fall 15
    server web-node2  10.0.0.100:32769 check inter 2000 rise 30 fall 15

5、启动 haproxy

systemctl start haproxy
systemctl enable haproxy

6、使用浏览器访问 hapeoxy 监听的 8000 端口可以看到负载的情况

7、使用浏览器访问：http://10.0.0.100:8888/haproxy-status

可以看到后端节点的监控状况

安装 socat 直接操作 socket 控制 haproxy

1、安装软件

yum install socat.x86_64 -y

2、查看帮助

[root@docker01 web_data]# echo "help"|socat stdio /var/lib/haproxy/stats

3、下线后端节点

echo "disable server backend_www_example_com/web-node2"|socat stdio /var/lib/haproxy/stats

4、上线后端节点

echo "enable server backend_www_example_com/web-node3"|socat stdio /var/lib/haproxy/stats

5、编写 php 测试页，放到 /data/web_data 下，在浏览器中访问可以查看当前的节点

[root@docker01 web_data]# vim check.php
<html>
    <head>
        <title>PHP测试</title>
    </head>
    <body>
        <?php  echo '<p>Hello World </p>'; ?>
        <?php  echo "访问的服务器地址是:"."<fontcolor=red>".$_SERVER['SERVER_ADDR']."</font>"."<br>";
        echo"访问的服务器域名是:"."<fontcolor=red>".$_SERVER['SERVER_NAME']."</font>"."<br>";
        ?>
    </body>
</html>

重启 docker 服务，容器全部退出的解决办法

在启动是指定自动重启

docker run  --restart=always

修改 docker 默认配置文件

# 添加上下面这行
"live-restore": true

docker server 配置文件 /etc/docker/daemon.json 参考

[root@docker02 ~]# cat  /etc/docker/daemon.json 
{
  "registry-mirrors": ["https://registry.docker-cn.com"],
  "graph": "/opt/mydocker", # 修改数据的存放目录到/opt/mydocker/，原/var/lib/docker/
  "insecure-registries": ["10.0.0.100:5000"],
  "live-restore": true
}

重启生效，只对在此之后启动的容器生效

[root@docker01 ~]# systemctl restart  docker.service

Docker 网络类型

docker 的网络类型

Bridge 默认 docker 网络隔离基于网络命名空间，在物理机上创建 docker 容器时会为每一个 docker 容器分配网络命名空间，并且把容器 IP 桥接到物理机的虚拟网桥上。

不为容器配置网络功能

此模式下创建容器是不会为容器配置任何网络参数的，如：容器网卡、IP、通信路由等，全部需要自己去配置。

[root@docker01 ~]# docker run  -it --network none busybox:latest  /bin/sh 
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever

与其他容器共享网络配置

此模式和 host 模式很类似，只是此模式创建容器共享的是其他容器的 IP 和端口而不是物理机，此模式容器自身是不会配置网络和端口，创建此模式容器进去后，你会发现里边的 IP 是你所指定的那个容器 IP 并且端口也是共享的，而且其它还是互相隔离的，如进程等。

[root@docker01 ~]# docker run  -it --network container:mywordpress_db_1  busybox:latest  /bin/sh 
/ # ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue 
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
105: eth0@if106: <BROADCAST,MULTICAST,UP,LOWER_UP,M-DOWN> mtu 1500 qdisc noqueue 
    link/ether 02:42:ac:12:00:03 brd ff:ff:ff:ff:ff:ff
    inet 172.18.0.3/16 brd 172.18.255.255 scope global eth0
       valid_lft forever preferred_lft forever

使用宿主机网络

此模式创建的容器没有自己独立的网络命名空间，是和物理机共享一个 Network Namespace，并且共享物理机的所有端口与 IP，并且这个模式认为是不安全的。

[root@docker01 ~]# docker run  -it --network host  busybox:latest  /bin/sh

查看网络列表

[root@docker01 ~]# docker network list 
NETWORK ID          NAME                  DRIVER              SCOPE
b15e8a720d3b        bridge                bridge              local
345d65b4c2a0        host                  host                local
bc5e2a32bb55        mywordpress_default   bridge              local
ebf76eea91bb        none                  null                local

用 PIPEWORK 为 docker 容器配置独立 IP

1、安装 pipework

wget https://github.com/jpetazzo/pipework/archive/master.zip
unzip master.zip 
cp pipework-master/pipework  /usr/local/bin/
chmod +x /usr/local/bin/pipework

2、配置桥接网卡

安装桥接工具

yum install bridge-utils.x86_64 -y

修改网卡配置，实现桥接

# 修改eth0配置，让br0实现桥接
[root@docker01 ~]# cat /etc/sysconfig/network-scripts/ifcfg-eth0 
TYPE=Ethernet
BOOTPROTO=static
NAME=eth0
DEVICE=eth0
ONBOOT=yes
BRIDGE=br0
[root@docker01 ~]# cat /etc/sysconfig/network-scripts/ifcfg-br0 
TYPE=Bridge
BOOTPROTO=static
NAME=br0
DEVICE=br0
ONBOOT=yes
IPADDR=10.0.0.100
NETMASK=255.255.255.0
GATEWAY=10.0.0.254
DNS1=223.5.5.5
# 重启网络
[root@docker01 ~]# /etc/init.d/network restart

3、运行一个容器镜像测试：

pipework br0 $(docker run -d -it -p 6880:80 --name  httpd_pw httpd) 10.0.0.220/24@10.0.0.254

在其他主机上测试端口及连通性

[root@docker01 ~]# curl 10.0.0.220
<html><body><h1>It works!</h1></body></html>
[root@docker01 ~]# ping 10.0.0.220 -c 1
PING 10.0.0.220 (10.0.0.220) 56(84) bytes of data.
64 bytes from 10.0.0.220: icmp_seq=1 ttl=64 time=0.043 ms

4、再运行一个容器，设置网路类型为 none：

pipework br0 $(docker run -d -it --net=none --name test httpd:2.4) 10.0.0.221/24@10.0.0.254

进行访问测试

[root@docker01 ~]# curl 10.0.0.221
<html><body><h1>It works!</h1></body></html>

5、重启容器后需要再次指定：

pipework br0 testduliip  172.16.146.113/24@172.16.146.1
pipework br0 testduliip01  172.16.146.112/24@172.16.146.1

Docker 跨主机通信之 macvlan

创建网络

[root@docker01 ~]# docker network  create --driver macvlan  --subnet 10.1.0.0/24 --gateway 10.1.0.254 -o parent=eth0  macvlan_1
33a1f41dcc074f91b5bd45e7dfedabfb2b8ec82db16542f05213839a119b62ca

设置网卡为混杂模式

ip link set eth0 promisc on

创建使用 macvlan 网络容器

[root@docker02 ~]# docker run  -it --network macvlan_1  --ip=10.1.0.222 busybox /b

docker 企业级镜像仓库 harbor

容器管理

[root@docker01 harbor]# pwd
/opt/harbor
[root@docker01 harbor]# docker-compose stop

1、安装 docker、docker-compose、下载 harbor

cd /opt && https://storage.googleapis.com/harbor-releases/harbor-offline-installer-v1.3.0.tgz
tar xf harbor-offline-installer-v1.3.0.tgz

2、修改主机及 web 界面密码

[root@docker01 harbor]# vim harbor.cfg 
    ···
    hostname = 10.0.0.100
    harbor_admin_password = Harbor12345
    ···

3、执行安装脚本

[root@docker01 harbor]# ./install.sh

浏览器访问 http://10.0.0.11

添加一个项目

4、镜像推送到仓库的指定项目

[root@docker02 ~]# docker  tag centos:6.8  10.0.0.100/clsn/centos6.8:1.0
[root@docker02 ~]#  
[root@docker02 ~]# docker images 
REPOSITORY                  TAG                 IMAGE ID            CREATED             SIZE
busybox                     latest              5b0d59026729        8 days ago          1.15MB
10.0.0.100/clsn/centos6.8   1.0                 6704d778b3ba        2 months ago        195MB
centos                      6.8                 6704d778b3ba        2 months ago        195MB
[root@docker02 ~]# docker login 10.0.0.100
Username: admin
Password: 
Login Succeeded

5、推送镜像

[root@docker02 ~]# docker push 10.0.0.100/clsn/centos6.8 
The push refers to repository [10.0.0.100/clsn/centos6.8]
e00c9229b481: Pushing  13.53MB/194.5MB

6、在 web 界面里查看

使用容器的建议

1. 不要以拆分方式进行应用程序发布

2. 不要创建大型镜像

3. 不要在单个容器中运行多个进程

4. 不要再镜像内保存凭证，不要依赖 IP 地址

5. 以非 root 用户运行进程

6. 不要使用 “最新” 标签

7. 不要利用运行中的容器创建镜像

8. 不要使用单层镜像

9. 不要将数据存放在容器内

关于 Docker 容器的监控

容器的基本信息

包括容器的数量、ID、名称、镜像、启动命令、端口等信息

容器的运行状态

统计各状态的容器的数量，包括运行中、暂停、停止及异常退出

容器的用量信息

统计容器的 CPU 使用率、内存使用量、块设备 I/O 使用量、网络使用情况等资源的使用情况

【DEV18.1】导出功能升级

wangbaochen — Thu, 08 Apr 2021 15:24:05 +0800

由于用户导出需求的日渐提高，添加 ExportData(ExportOptionsEx) 重载，开放导出设置选项，满足用户的不同需求

ExportOptionsEx 类位于 WnPlatform 中，以下为属性：

1. SheetName

名称：工作表名称
类型：string
描述：设置导出文档在 Excel 中的工作表名称
默认值：string.Empty

2. ShowPageTitle

名称：显示每页标题
类型：DefaultBoolean
描述：设置是否为导出文档的每个打印预览页显示标题
默认值：DefaultBoolean.Default

3. LayoutMode

名称：文档模式
类型：LayoutMode
描述：设置数据是以常规模式还是以本机 Excel 表格的形式导出
默认值：LayoutMode.Standard
来源：Devexpress.Printing.v18.1.Core
展示：
- Standard - 默认导出模式
- Table - 启用导出到本地 Excel 表格

4. AllowBandHeaderCellMerge

名称：允许合并表头
类型：DefaultBoolean
描述：设置导出文档中的带头是否启用单元格合并
默认值：DefaultBoolean.Default，DefaultBoolean.Default 值相当于 DefaultBoolean.True

5. AllowCellMerge

名称：允许单元格合并
类型：DefaultBoolean
描述：设置是否在导出的文档中启用单元格合并
默认值：DefaultBoolean.Default

6. AllowFixedColumns

名称：允许固定列
类型：DefaultBoolean
描述：设置在网格控件中启用的左固定列是否在导出的文档中固定
默认值：DefaultBoolean.Default

7. AllowFixedColumnHeaderPanel

名称：允许固定表头行
类型：DefaultBoolean
描述：设置表头是否固定在导出文档的顶部，而不是垂直滚动
默认值：DefaultBoolean.Default

8. ShowColumnHeaders

名称：是否显示表头
类型：DefaultBoolean
描述：设置列头在导出的文档中是否可见
默认值：DefaultBoolean.Default

9. AllowGrouping

名称：是否允许分组
类型：DefaultBoolean
描述：设置从源导出到输出文档的数据是否分组
默认值：DefaultBoolean.Default

10. AllowSortingAndFiltering

名称：是否允许排序和过滤
类型：DefaultBoolean
描述：设置是否在导出的文档中启用列的排序和过滤功能
默认值：DefaultBoolean.Default

11. ShowGroupSummaries

名称：是否显示分组摘要
类型：DefaultBoolean
描述：设置是否在导出的文档中启用分组摘要
默认值：DefaultBoolean.Default，DefaultBoolean.Default 值相当于 DefaultBoolean.True

12. AllowLookupValues

名称：是否导出下拉列表
类型：DefaultBoolean
描述：设置是否导出组合框和查找列的查找值
默认值：DefaultBoolean.Default

13. AllowConditionFormatting

名称：是否导出条件规则
类型：DefaultBoolean
描述：设置是否在导出的文档中保留应用于列的条件格式化规则
默认值：DefaultBoolean.Default，DefaultBoolean.Default 值相当于 DefaultBoolean.True

14.TextExportMode

名称：文本导出模式
类型：TextExportMode
描述：指定是否在导出的 XLS（或 XLSX）文档中的单元格中使用绑定数据集的数据字段格式。
默认值：TextExportMode.Value：将所有数据字段导出到 XLS（或 XLSX）文件中，使用与原始文件中相同的格式。TextExportMode.Text：将所有的数据字段以字符串的形式导出到 XLS（或 XLSX）文件，并将相应的非 HTML 格式嵌入到这些字符串中。HTML 标签被忽略。

【转】解决 winform 窗体控件多，加载慢、卡顿的问题

wangbaochen — Tue, 06 Apr 2021 17:02:21 +0800

protected override CreateParams CreateParams
{
     get
     {
         CreateParams cp = base.CreateParams;
         cp.ExStyle |= 0x02000000; // 用双缓冲绘制窗口的所有子控件
         return cp;
     }
}

将此方法放在需要优化的窗体代码中即可。如下图：

原https://blog.csdn.net/weixin_42288432/article/details/103207077
@tianjiangang 田建刚提供

DEV18.1 升级问题汇总以及解决方案

wangbaochen — Tue, 06 Apr 2021 09:17:07 +0800

此贴用来收集 DEV18.1 的升级问题，以及解决方案

关于 flash 过期不显示的解决方案之一

wangbaochen — Thu, 14 Jan 2021 01:16:16 +0800

flash player 将在 2020 年 12 月不再支持

程序不影响使用可以删除两个.swf 文件，删除后将会显示静态图。
也可使用永久解决方案，删除 flash
https://pan.lttc.cn/s/2LpSRPSzmEtfYQA
删除之后的隐患为使用 flash 的网页不在显示内容，例如下图，不显示上传按钮

可根据自身情况，合理使用。

关于提示信息延时消失的解决方案之一

wangbaochen — Thu, 24 Dec 2020 17:07:38 +0800

https://pan.lttc.cn/s/QJ3cKB5GfFErbCq

关于附件无法打开的解决方案之一

wangbaochen — Sat, 17 Oct 2020 00:18:06 +0800

上传的文件无法在线预览，或者报错 “没有注册类 (异常来自 HRESULT:0x80040154 (REGDB_E_CLASSNOTREG))”，现提供一个解决方案。

从 %\PEMSoft\鲁泰集团 ERP 文件夹中获取 WebOffice.ocx 文件

32 位系统：将文件放到%systemroot%\System32 目录；
64 位系统：将文件放到%systemroot%\SysWoW64 目录。

使用管理员身份运行 cmd，进入文件存放目录中，

32 位：cd %systemroot%\System32；
64 位：cd %systemroot%\SysWoW64

执行 regsvr32.exe WebOffice.ocx，注册成功之后，重新打开 ERP 即可

关于 wnText 控件右键菜单的解决方案

wangbaochen — Thu, 16 Apr 2020 20:52:21 +0800

1.Load 事件中注册鼠标点击事件：

(wnText1.OriginControl as WnTextEditorBase).TextEdit.MouseClick += WnFormDemo_MouseClick;

2.拷贝一下方法：

private static void InitRichTextBoxContextMenu(RichTextBox textBox)
        {
            //创建剪切子菜单
            var cutMenuItem = new MenuItem("剪切");
            cutMenuItem.Click += (sender, eventArgs) => textBox.Cut();

            //创建复制子菜单
            var copyMenuItem = new MenuItem("复制");
            copyMenuItem.Click += (sender, eventArgs) => textBox.Copy();

            //创建粘贴子菜单
            var pasteMenuItem = new MenuItem("粘贴");
            pasteMenuItem.Click += (sender, eventArgs) => textBox.Paste();

            //创建右键菜单并将子菜单加入到右键菜单中
            var contextMenu = new ContextMenu();
            contextMenu.MenuItems.Add(cutMenuItem);
            contextMenu.MenuItems.Add(copyMenuItem);
            contextMenu.MenuItems.Add(pasteMenuItem);

            textBox.ContextMenu = contextMenu;
        }

3.调用

private void WnFormDemo_MouseClick(object sender, MouseEventArgs e)
       {
           InitRichTextBoxContextMenu((wnText1.OriginControl as WnTextEditorBase).TextEdit);
       }

关于获取 WnGrid 中过滤或排序行的方法

wangbaochen — Wed, 15 Apr 2020 20:42:37 +0800

wnGridPbcdxx.Columns["Qswz"].SortOrder = ColumnSortOrder.Ascending; //排序
var listRow = wnGridPbcdxx.GridView.DataController.GetAllFilteredAndSortedRows(); //获取所有已经排序或者过滤的数据
var listRowView = listRow.Cast<DataRowView>().ToList(); //转换成List<DataRowView>

关于 WnGrid 多列排序的一种解决方案

wangbaochen — Thu, 09 Apr 2020 16:40:46 +0800

长期以来客户都有多列排序的需求，一直得不到解决，经过这几天头悬梁锥刺股的查询资料，终于在我英语四级的水平下在Dev 官网找到答案，简单到想哭。解决方案：Shift+ 鼠标左键点击列标题 ShowTime:

关于 wnGrid 列排序的探讨

wangbaochen — Sat, 14 Mar 2020 02:22:29 +0800

GridView -> OptionsCustomization -> AllowSort 是否禁止所有列排序
Columns -> Column options ->AllowSort 是否禁止当前列排序

以下为代码：