1 using System;

 2 using System.Collections.Generic;

 3 using System.Linq;

 4 using System.Net.Http;

 5 using Consul;

 6 using Microsoft.AspNetCore.Mvc;

 7 using Microsoft.Extensions.Logging;

 8 using PatrickLiu.MicroService.Interfaces;

 9 using PatrickLiu.MicroService.Models;

10

11 namespace PatrickLiu.MicroService.Client.Controllers

12 {

13     public class HomeController : Controller

14     {

15         private readonly ILogger<HomeController> _logger;

16         private readonly IUserService _userService;

17         private static int index;

18

19         /// <summary>

20         /// 初始化该类型的新实例。

21         /// </summary>

22         /// <param name="logger">注入日志对象。</param>

23         /// <param name="userService">注入用户服务对象。</param>

24         public HomeController(ILogger<HomeController> logger, IUserService userService)

25         {

26             _logger = logger;

27             _userService = userService;

28         }

29

30         /// <summary>

31         /// 首页。

32         /// </summary>

33         /// <returns></returns>

34         public IActionResult Index()

35         {

36

37             #region 通过 Ocelot 网关访问服务实例。

38

39             string url = "http://localhost:8080/gate/users/all";//Ocelot 集群的Nginx反向代理地址

40

41             #endregion

42

43             string content = InvokeAPI(url);

44             this.ViewBag.Users = Newtonsoft.Json.JsonConvert.DeserializeObject<IEnumerable<User>>(content);

45             Console.WriteLine($"This is {url} Invoke.");

46

47             #endregion

48

49             return View();

50         }

51

52

53         /// <summary>

54         /// 封装 HttpClient 实例，提供 Http 调用。

55         /// </summary>

56         /// <param name="url">http url 的地址。</param>

57         /// <returns>返回结束数据，格式：JSON。</returns>

58         public static string InvokeAPI(string url)

59         {

60             using (HttpClient client = new HttpClient())

61             {

62                 HttpRequestMessage message = new HttpRequestMessage();

63                 message.Method = HttpMethod.Get;

64                 message.RequestUri = new Uri(url);

65                 var result = client.SendAsync(message).Result;

66                 string conent = result.Content.ReadAsStringAsync().Result;

67                 return conent;

68             }

69         }

70     }

71 }

 1 using PatrickLiu.MicroService.Models;

 2 using System.Collections.Generic;

 3

 4 namespace PatrickLiu.MicroService.Interfaces

 5 {

 6     /// <summary>

 7     /// 用户服务的接口定义。

 8     /// </summary>

 9     public interface IUserService

10     {

11         /// <summary>

12         /// 查找指定主键的用户实例对象。

13         /// </summary>

14         /// <param name="id">用户的主键。</param>

15         /// <returns>返回查找到的用户实例对象。</returns>

16         User FindUser(int id);

17

18         /// <summary>

19         /// 获取所有用户的实例集合。

20         /// </summary>

21         /// <returns>返回所有的用户实例。</returns>

22         IEnumerable<User> UserAll();

23     }

24 }

 1 using System;

 2

 3 namespace PatrickLiu.MicroService.Models

 4 {

 5     /// <summary>

 6     /// 用户模型。

 7     /// </summary>

 8     public class User

 9     {

10         /// <summary>

11         /// 获取或者设置用户主键。

12         /// </summary>

13         public int ID { get; set; }

14

15         /// <summary>

16         /// 获取或者设置用户姓名。

17         /// </summary>

18         public string Name { get; set; }

19

20         /// <summary>

21         /// 获取或者设置用户账号名称。

22         /// </summary>

23         public string Account { get; set; }

24

25         /// <summary>

26         /// 获取或者设置用户密码。

27         /// </summary>

28         public string Password { get; set; }

29

30         /// <summary>

31         /// 获取或者设置用户的电子邮箱地址。

32         /// </summary>

33         public string Email { get; set; }

34

35         /// <summary>

36         /// 获取或者设置用户角色。

37         /// </summary>

38         public string Role { get; set; }

39

40         /// <summary>

41         /// 获取或者设置用户的登录时间。

42         /// </summary>

43         public DateTime LoginTime { get; set; }

44     }

45 }

 1 using PatrickLiu.MicroService.Interfaces;

 2 using PatrickLiu.MicroService.Models;

 3 using System;

 4 using System.Collections.Generic;

 5 using System.Linq;

 6

 7 namespace PatrickLiu.MicroService.Services

 8 {

 9     /// <summary>

10     /// 实现用户服务接口的实现类型。

11     /// </summary>

12     public class UserService : IUserService

13     {

14         private IList<User> dataList;

15

16         /// <summary>

17         /// 初始化类型的实例

18         /// </summary>

19         public UserService()

20         {

21             dataList = new List<User>()

22             { new User {ID=1,Name="黄飞鸿",Account="HuangFeiHong",Password="HuangFeiHong123456",Email="huangFeiHong@sina.com", Role="Admin", LoginTime=DateTime.Now },

23             new User {ID=2,Name="洪熙官",Account="HongXiGuan",Password="HongXiGuan54667",Email="HongXiGuan@sina.com", Role="Admin", LoginTime=DateTime.Now.AddDays(-5) },

24             new User {ID=3,Name="方世玉",Account="FangShiYu",Password="FangShiYu112233",Email="fangShiYu@163.com", Role="Admin", LoginTime=DateTime.Now.AddDays(-30) },

25             new User {ID=4,Name="苗翠花",Account="MiaoCuiHua",Password="MiaoCuiHua887766",Email="miaoCuiHua@sohu.com", Role="Admin", LoginTime=DateTime.Now.AddDays(-90) },

26             new User {ID=5,Name="严咏春",Account="YanYongChun",Password="YanYongChun09392",Email="yanYongChun@263.com", Role="Admin", LoginTime=DateTime.Now.AddMinutes(-50) }};

27         }

28

29         /// <summary>

30         /// 查找指定主键的用户实例对象。

31         /// </summary>

32         /// <param name="id">用户的主键。</param>

33         /// <returns>返回查找到的用户实例对象。</returns>

34         public User FindUser(int id)

35         {

36             return dataList.FirstOrDefault(user => user.ID == id);

37         }

38

39         /// <summary>

40         /// 获取所有用户的实例集合。

41         /// </summary>

42         /// <returns>返回所有的用户实例。</returns>

43         public IEnumerable<User> UserAll()

44         {

45             return dataList;

46         }

47     }

48 }

  1 using System;

  2 using System.Collections.Generic;

  3 using System.Linq;

  4 using System.Threading;

  5 using Microsoft.AspNetCore.Authorization;

  6 using Microsoft.AspNetCore.Mvc;

  7 using Microsoft.Extensions.Configuration;

  8 using Microsoft.Extensions.Logging;

  9 using PatrickLiu.MicroService.Interfaces;

 10 using PatrickLiu.MicroService.Models;

 11

 12 namespace PatrickLiu.MicroService.ServiceInstance.Controllers

 13 {

 14     /// <summary>

 15     /// 用户的 API 类型。

 16     /// </summary>

 17     [Route("api/[controller]")]

 18     [ApiController]

 19     public class UsersController : ControllerBase

 20     {

 21         #region 私有字段

 22

 23         private readonly ILogger<UsersController> _logger;

 24         private readonly IUserService _userService;

 25         private IConfiguration _configuration;

 26

 27         #endregion

 28

 29         #region 构造函数

 30

 31         /// <summary>

 32         /// 初始化该类型的新实例。

 33         /// </summary>

 34         /// <param name="logger">日志记录器。</param>

 35         /// <param name="userService">用户服务接口。</param>

 36         /// <param name="configuration">配置服务。</param>

 37         public UsersController(ILogger<UsersController> logger, IUserService userService, IConfiguration configuration)

 38         {

 39             _logger = logger;

 40             _userService = userService;

 41             _configuration = configuration;

 42         }

 43

 44         #endregion

 45

 46         #region 实例方法

 47

 48         /// <summary>

 49         /// 获取一条记录

 50         /// </summary>

 51         /// <param name="id"></param>

 52         /// <returns></returns>

 53         [HttpGet]

 54         [Route("Get")]

 55         public User Get(int id)

 56         {

 57             return _userService.FindUser(id);

 58         }

 59

 60         /// <summary>

 61         /// 获取所有记录。

 62         /// </summary>

 63         /// <returns></returns>

 64         [HttpGet]

 65         [Route("All")]

 66         //[Authorize]

 67         public IEnumerable<User> Get()

 68         {

 69             Console.WriteLine($"This is UsersController {this._configuration["port"]} Invoke");

 70

 71             return this._userService.UserAll().Select((user => new User

 72             {

 73                 ID = user.ID,

 74                 Name = user.Name,

 75                 Account = user.Account,

 76                 Password = user.Password,

 77                 Email = user.Email,

 78                 Role = $"{this._configuration["ip"]}：{this._configuration["port"]}",

 79                 LoginTime = user.LoginTime

 80             })); ;

 81         }

 82

 83         /// <summary>

 84         /// 超时处理

 85         /// </summary>

 86         /// <returns></returns>

 87         [HttpGet]

 88         [Route("Timeout")]

 89         public IEnumerable<User> Timeout()

 90         {

 91             Console.WriteLine($"This is Timeout Start");

 92             //超时设置。

 93             Thread.Sleep(3000);

 94

 95             Console.WriteLine($"This is Timeout End");

 96

 97             return this._userService.UserAll().Select((user => new User

 98             {

 99                 ID = user.ID,

100                 Name = user.Name,

101                 Account = user.Account,

102                 Password = user.Password,

103                 Email = user.Email,

104                 Role = $"{this._configuration["ip"]}：{this._configuration["port"]}",

105                 LoginTime = user.LoginTime

106             })); ;

107         }

108

109         #endregion

110     }

111 }

 1 using Consul;

 2 using Microsoft.Extensions.Configuration;

 3 using Microsoft.Extensions.Hosting;

 4 using System;

 5

 6 namespace PatrickLiu.MicroService.ServiceInstance.Utilities

 7 {

 8     /// <summary>

 9     /// Consul 静态扩展类。

10     /// </summary>

11     public static class ConsulExtension

12     {

13         /// <summary>

14         ///类型初始化器，初始化 Consul 网址和数据中心。

15         /// </summary>

16         static ConsulExtension()

17         {

18             Uri = new Uri("http://localhost:8500");

19             DataCenter = "dc1";

20         }

21

22         /// <summary>

23         /// 获取或者设置 Consul 的网址。

24         /// </summary>

25         public static Uri Uri { get; set; }

26

27         /// <summary>

28         /// 获取或者设置数据中心。

29         /// </summary>

30         public static string DataCenter { get; set; }

31

32         /// <summary>

33         /// 向 Consul 服务中心注册服务实例。

34         /// </summary>

35         /// <param name="configuration">配置对象。</param>

36         /// <param name="consulServiceName">在 Consul 服务中心注册的服务类别名称，多个实例的 ID 可以属于一个服务类别名称。</param>

37         /// <param name="serviceID">服务实例的主键值，必须唯一。</param>

38         public static void ConsulRegist(this IConfiguration configuration,string consulServiceName, string serviceID)

39         {

40             if (string.IsNullOrEmpty(consulServiceName) || string.IsNullOrWhiteSpace(consulServiceName))

41             {

42                 throw new ArgumentNullException("consulServiceName is null");

43             }

44             if (string.IsNullOrEmpty(serviceID) || string.IsNullOrWhiteSpace(serviceID))

45             {

46                 throw new ArgumentNullException("serviceID is null.");

47             }

48

49             using (ConsulClient client = new ConsulClient(config =>

50             {

51                 config.Address = Uri;

52                 config.Datacenter = DataCenter;

53             }))

54             {

55                 string ip = configuration["ip"];

56                 int port = int.Parse(configuration["port"]);

57                 int weight = string.IsNullOrWhiteSpace(configuration["weight"]) ? 1 : int.Parse(configuration["weight"]);

58

59                 client.Agent.ServiceRegister(new AgentServiceRegistration()

60                 {

61                     ID = serviceID,

62                     Name = consulServiceName,

63                     Address = ip,

64                     Port = port,

65                     Tags = new string[] { weight.ToString() },

66                     Check = new AgentServiceCheck()

67                     {

68                         Interval = TimeSpan.FromSeconds(12),

69                         HTTP = $"http://{ip}:{port}/API/Health/Index",

70                         Timeout = TimeSpan.FromSeconds(5),

71                         DeregisterCriticalServiceAfter = TimeSpan.FromSeconds(20)

72                     }

73                 }).Wait();

74                 Console.WriteLine($"注册服务：{ip}:{port}--Weight:{weight}");

75             };

76         }

77

78         /// <summary>

79         /// 向 Consul 服务中心注销服务实例。

80         /// </summary>

81         /// <param name="applicationLifetime">配置对象。</param>

82         /// <param name="serviceID">服务实例的主键值，必须唯一。</param>

83         public static void ConsulDown(this IHostApplicationLifetime applicationLifetime, string serviceID)

84         {

85             if (string.IsNullOrEmpty(serviceID) || string.IsNullOrWhiteSpace(serviceID))

86             {

87                 throw new ArgumentNullException("serviceID is null");

88             }

89             applicationLifetime.ApplicationStopped.Register(() =>

90             {

91                 using (var consulClient = new ConsulClient(config => { config.Address = Uri; config.Datacenter = DataCenter; }))

92                 {

93                     Console.WriteLine("服务已经退出");

94                     consulClient.Agent.ServiceDeregister(serviceID);

95                 }

96             });

97         }

98     }

99 }

 1 using Consul;

 2 using Microsoft.AspNetCore.Builder;

 3 using Microsoft.AspNetCore.Hosting;

 4 using Microsoft.Extensions.Configuration;

 5 using Microsoft.Extensions.DependencyInjection;

 6 using Microsoft.Extensions.Hosting;

 7 using PatrickLiu.MicroService.Interfaces;

 8 using PatrickLiu.MicroService.ServiceInstance.Utilities;

 9 using PatrickLiu.MicroService.Services;

10 using System;

11 using System.Security.Policy;

12

13 namespace PatrickLiu.MicroService.ServiceInstance

14 {

15     /// <summary>

16     /// 应用程序启动配置

17     /// </summary>

18     public class Startup

19     {

20         /// <summary>

21         /// 构造函数注入配置对象

22         /// </summary>

23         /// <param name="configuration">配置实例</param>

24         public Startup(IConfiguration configuration)

25         {

26             Configuration = configuration;

27         }

28

29         /// <summary>

30         /// 获取配置实例。

31         /// </summary>

32         public IConfiguration Configuration { get; }

33

34         /// <summary>

35         /// 配置注入对象。

36         /// </summary>

37         /// <param name="services"></param>

38         public void ConfigureServices(IServiceCollection services)

39         {

40             //其他代码省略

41             services.AddSingleton<IUserService, UserService>();

42         }

43

44         /// <summary>

45         /// 配置 HTTP 处理管道。

46         /// </summary>

47         /// <param name="app">应用程序对象。</param>

48         /// <param name="env">环境对象。</param>

49         /// <param name="applicationLifetime">应用程序生命周期的对象。</param>

50         public void Configure(IApplicationBuilder app, IWebHostEnvironment env,IHostApplicationLifetime applicationLifetime)

51         {

52             //其他代码省略

53             #region Consul 注册

54

55             string serviceID = $"Service:{Configuration["ip"]}:{Configuration["port"]}---{Guid.NewGuid()}";

56             string consuleServiceName = "PatrickLiuService";

57

58             //注册服务。

59             Configuration.ConsulRegist(consuleServiceName,serviceID);

60

61             //注销服务

62             applicationLifetime.ConsulDown(serviceID);

63

64             #endregion

65         }

66     }

67 }