理解依赖注入（IOC）和学习Unity

IOC:英文全称：Inversion of Control，中文名称：控制反转，它还有个名字叫依赖注入（Dependency Injection）。
作用：将各层的对象以松耦合的方式组织在一起，解耦，各层对象的调用完全面向接口。当系统重构的时候，代码的改写量将大大减少。
理解依赖注入：当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常有调用者来创建被调用者的实例。然而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IOC容器来完成，然后注入调用者，因此也称为依赖注入。
举个有意思的例子（来源于互联网）假如我们要设计一个Girl和一个Boy类，其中Girl有Kiss方法，即Girl想要Kiss一个Boy，首先问题是Girl如何认识Boy？在我们中国常见的MM认识GG的方式有以下几种：A 青梅竹马    B 亲友介绍   C 父母包办哪一种是最好的？
1.青梅竹马：很久很久以前，有个有钱的地主家的一闺女叫Lily，她老爸把她许配给县太爷的儿子Jimmy，属于指腹为婚，Lily非常喜欢kiss,但是只能kiss Jimmypublic class Lily{  public Jimmy jimmy;   public Girl()  {  jimmy=new Jimmy();  }  public void Kiss()  {  jimmy.Kiss();  }  }  public class Jimmy  {  public void Kiss()  {  Console.WriteLine("kissing");  }  }  
这样导致Lily对Jimmy的依赖性非常强，紧耦合。2.亲友介绍：经常Kiss同一个人令Lily有些厌恶了，她想尝试新人，于是与Jimmy分手了，通过亲朋好友（中间人）来介绍public class Lily{  public Boy boy;   public Girl()  {  boy=BoyFactory.createBoy();  }  public void Kiss()  {  boy.Kiss();  }  }  亲友介绍，固然是好。如果不满意，尽管另外换一个好了。但是，亲友BoyFactory经常是以Singleton的形式出现，不然就是，存在于Globals，无处不在，无处不能。实在是太繁琐了一点，不够灵活。我为什么一定要这个亲友掺和进来呢？为什么一定要付给她介绍费呢？万一最好的朋友爱上了我的男朋友呢？3.父母包办：一切交给父母，自己不用非吹灰之力，Lily在家只Kisspublic class Lily{  public Boy boy;   public Girl(Boy boy)  {  this.boy=boy;  }  public void Kiss()  {  this.boy.Kiss();  }  }  Well，这是对Girl最好的方法，只要想办法贿赂了Girl的父母，并把Boy交给他。那么我们就可以轻松的和Girl来Kiss了。看来几千年传统的父母之命还真是有用哦。至少Boy和Girl不用自己瞎忙乎了。这就是IOC，将对象的创建和获取提取到外部。由外部容器提供需要的组件。在设计模式中我们应该还知道依赖倒转原则，应是面向接口编程而不是面向功能实现，好处是：多实现可以任意切换，我们的Boy应该是实现Kissable接口。这样一旦Girl不想kiss可恶的Boy的话，还可以kiss可爱的kitten和慈祥的grandmother好在.net中微软有一个轻量级的IoC框架Unity，支持构造器注入，属性注入，方法注入如下图所示具体使用方法如下图所示using System;  using Microsoft.Practices.Unity;  namespace ConsoleApplication9  
{  class Program  {  static void Main(string[] args)  {  //创建容器  IUnityContainer container=new UnityContainer();  //注册映射  container.RegisterType<IKiss, Boy>();  //得到Boy的实例  var boy = container.Resolve<IKiss>();  Lily lily = new Lily(boy);  lily.kiss();  }  }  public interface IKiss  {  void kiss();  }  public class Lily:IKiss  {  public IKiss boy;   public Lily(IKiss boy)  {  this.boy=boy;  }  public void kiss()  {  boy.kiss();  Console.WriteLine("lily kissing");  }  }  public class Boy : IKiss  {  public void kiss()  {  Console.WriteLine("boy kissing");  }  }  
}  
如果采用配置文件注册的话<?xml version="1.0" encoding="utf-8" ?>  
<configuration>  <configSections>  <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>  </configSections>  <unity>  <containers>  <container name="defaultContainer">  <register type="命名空间.接口类型1,命名空间" mapTo="命名空间.实现类型1,命名空间" />  <register type="命名空间.接口类型2,命名空间" mapTo="命名空间.实现类型2,命名空间" />  </container>  </containers>  </unity>  
</configuration>  配置的后台代码：UnityConfigurationSection configuration = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName)  as UnityConfigurationSection;  
configuration.Configure(container, "defaultContainer");  
可以通过方法ResolveAll来得到所有注册对象的实例：
var Instances = container.Resolve<IKiss>();Martin Fowler在那篇著名的文章《Inversion of Control Containers and the Dependency Injection pattern》中将具体依赖注入划分为三种形式，即构造器注入、属性（设置）注入和接口注入,习惯将其划分为一种（类型）匹配和三种注入：类型匹配（Type Matching）：虽然我们通过接口（或者抽象类）来进行服务调用，但是服务本身还是实现在某个具体的服务类型中，这就需要某个类型注册机制来解决服务接口和服务类型之间的匹配关系；
构造器注入（Constructor Injection）：IoC容器会智能地选择选择和调用适合的构造函数以创建依赖的对象。如果被选择的构造函数具有相应的参数，IoC容器在调用构造函数之前解析注册的依赖关系并自行获得相应参数对象；
属性注入（Property Injection）：如果需要使用到被依赖对象的某个属性，在被依赖对象被创建之后，IoC容器会自动初始化该属性；
方法注入（Method Injection）：如果被依赖对象需要调用某个方法进行相应的初始化，在该对象创建之后，IoC容器会自动调用该方法。我们创建一个控制台程序，定义如下几个接口（IA、IB、IC和ID）和它们各自的实现类（A、B、C、D）。在类型A中定义了3个属性B、C和D，其类型分别为接口IB、IC和ID。其中属性B在构在函数中被初始化，以为着它会以构造器注入的方式被初始化；属性C上应用了DependencyAttribute特性，意味着这是一个需要以属性注入方式被初始化的依赖属性；属性D则通过方法Initialize初始化，该方法上应用了特性InjectionMethodAttribute，意味着这是一个注入方法在A对象被IoC容器创建的时候会被自动调用。public interface IA { }  public interface IB { }  public interface IC { }  public interface ID { }  public class A : IA  {  public IB B { get; set; }  [Dependency]  public IC C { get; set; }  public ID D { get; set; }  public A(IB b)  {  this.B = b;  }  [InjectionMethod]  public void Initalize(ID d)  {  this.D = d;  }  }  public class B : IB { }  public class C : IC { }  public class D : ID { }  然后我们为该应用添加一个配置文件，并定义如下一段关于Unity的配置。这段配置定义了一个名称为defaultContainer的Unity容器，并在其中完成了上面定义的接口和对应实现类之间映射的类型匹配。<?xml version="1.0" encoding="utf-8" ?>  
<configuration>  <configSections>  <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>  </configSections>  <unity>  <containers>  <container name="defaultContainer">  <register type="UnityDemo.IA,UnityDemo" mapTo="UnityDemo.A, UnityDemo"/>  <register type="UnityDemo.IB,UnityDemo" mapTo="UnityDemo.B, UnityDemo"/>  <register type="UnityDemo.IC,UnityDemo" mapTo="UnityDemo.C, UnityDemo"/>  <register type="UnityDemo.ID,UnityDemo" mapTo="UnityDemo.D, UnityDemo"/>  </container>  </containers>  </unity>  
</configuration>  最后在Main方法中创建一个代表IoC容器的UnityContainer对象，并加载配置信息对其进行初始化。然后调用它的泛型的Resolve方法创建一个实现了泛型接口IA的对象。最后将返回对象转变成类型A，并检验其B、C和D属性是否是空class Program  {  static void Main(string[] args)  {  UnityContainer container = new UnityContainer();  UnityConfigurationSection configuration = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName) as UnityConfigurationSection;  configuration.Configure(container, "defaultContainer");  A a = container.Resolve<IA>() as A;  if (null!=a)  {  Console.WriteLine("a.B==null?{0}",a.B==null?"Yes":"No");  Console.WriteLine("a.C==null?{0}", a.C == null ? "Yes" : "No");  Console.WriteLine("a.D==null?{0}", a.D == null ? "Yes" : "No");  }  }  }  从如下给出的执行结果我们可以得到这样的结论：通过Resolve<IA>方法返回的是一个类型为A的对象，该对象的三个属性被进行了有效的初始化。这个简单的程序分别体现了接口注入（通过相应的接口根据配置解析出相应的实现类型）、构造器注入（属性B）、属性注入（属性C）和方法注入（属性D）a.B == null ? Noa.C == null ? Noa.D == null ? No

http://www.cnblogs.com/zhangchenliang/archive/2013/01/08/2850970.html

IOC:英文全称：Inversion of Control，中文名称：控制反转，它还有个名字叫依赖注入（Dependency Injection）。
作用：将各层的对象以松耦合的方式组织在一起，解耦，各层对象的调用完全面向接口。当系统重构的时候，代码的改写量将大大减少。
理解依赖注入：
    当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常有调用者来创建被调用者的实例。然而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IOC容器来完成，然后注入调用者，因此也称为依赖注入。
举个有意思的例子（来源于互联网）

假如我们要设计一个Girl和一个Boy类，其中Girl有Kiss方法，即Girl想要Kiss一个Boy，首先问题是Girl如何认识Boy？
在我们中国常见的MM认识GG的方式有以下几种：
A 青梅竹马    B 亲友介绍   C 父母包办
哪一种是最好的？

1.青梅竹马：很久很久以前，有个有钱的地主家的一闺女叫Lily，她老爸把她许配给县太爷的儿子Jimmy，属于指腹为婚，Lily非常喜欢kiss,但是只能kiss Jimmy

  1. public class Lily{  
  2.         public Jimmy jimmy;   
  3.         public Girl()  
  4.         {  
  5.             jimmy=new Jimmy();  
  6.         }  
  7.         public void Kiss()  
  8.         {  
  9.             jimmy.Kiss();  
  10.         }  
  11.     }  
  12.   
  13.     public class Jimmy  
  14.     {  
  15.         public void Kiss()  
  16.         {  
  17.             Console.WriteLine("kissing");  
  18.         }  
  19.     }  

这样导致Lily对Jimmy的依赖性非常强，紧耦合。

2.亲友介绍：经常Kiss同一个人令Lily有些厌恶了，她想尝试新人，于是与Jimmy分手了，通过亲朋好友（中间人）来介绍

  1. public class Lily{  
  2.         public Boy boy;   
  3.   
  4.         public Girl()  
  5.         {  
  6.             boy=BoyFactory.createBoy();  
  7.         }  
  8.         public void Kiss()  
  9.         {  
  10.             boy.Kiss();  
  11.         }  
  12.     }  


亲友介绍，固然是好。如果不满意，尽管另外换一个好了。但是，亲友BoyFactory经常是以Singleton的形式出现，不然就是，存在于Globals，无处不在，无处不能。实在是太繁琐了一点，不够灵活。我为什么一定要这个亲友掺和进来呢？为什么一定要付给她介绍费呢？万一最好的朋友爱上了我的男朋友呢？

 

3.父母包办：一切交给父母，自己不用非吹灰之力，Lily在家只Kiss

  1. public class Lily{  
  2.         public Boy boy;   
  3.         public Girl(Boy boy)  
  4.         {  
  5.             this.boy=boy;  
  6.         }  
  7.         public void Kiss()  
  8.         {  
  9.             this.boy.Kiss();  
  10.         }  
  11.     }  

 

 

Well，这是对Girl最好的方法，只要想办法贿赂了Girl的父母，并把Boy交给他。那么我们就可以轻松的和Girl来Kiss了。看来几千年传统的父母之命还真是有用哦。至少Boy和Girl不用自己瞎忙乎了。这就是IOC，将对象的创建和获取提取到外部。由外部容器提供需要的组件。

在设计模式中我们应该还知道依赖倒转原则，应是面向接口编程而不是面向功能实现，好处是：多实现可以任意切换，我们的Boy应该是实现Kissable接口。这样一旦Girl不想kiss可恶的Boy的话，还可以kiss可爱的kitten和慈祥的grandmother

好在.net中微软有一个轻量级的IoC框架Unity，支持构造器注入，属性注入，方法注入如下图所示

具体使用方法如下图所示

  1. using System;  
  2.   
  3. using Microsoft.Practices.Unity;  
  4.   
  5.   
  6. namespace ConsoleApplication9  
  7. {  
  8.     class Program  
  9.     {  
  10.         static void Main(string[] args)  
  11.         {  
  12.             //创建容器  
  13.             IUnityContainer container=new UnityContainer();  
  14.             //注册映射  
  15.             container.RegisterType<IKiss, Boy>();  
  16.             //得到Boy的实例  
  17.             var boy = container.Resolve<IKiss>();  
  18.              
  19.             Lily lily = new Lily(boy);  
  20.             lily.kiss();  
  21.         }  
  22.     }  
  23.   
  24.   
  25.     public interface IKiss  
  26.     {  
  27.         void kiss();  
  28.     }  
  29.       
  30.   
  31.     public class Lily:IKiss  
  32.     {  
  33.   
  34.         public IKiss boy;   
  35.   
  36.         public Lily(IKiss boy)  
  37.         {  
  38.             this.boy=boy;  
  39.         }  
  40.         public void kiss()  
  41.         {  
  42.             boy.kiss();  
  43.             Console.WriteLine("lily kissing");  
  44.         }  
  45.     }  
  46.   
  47.     public class Boy : IKiss  
  48.     {  
  49.         public void kiss()  
  50.         {  
  51.             Console.WriteLine("boy kissing");  
  52.         }  
  53.     }  
  54. }  

如果采用配置文件注册的话

  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <configuration>  
  3.   <configSections>  
  4.     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>  
  5.   </configSections>  
  6.   <unity>  
  7.     <containers>  
  8.       <container name="defaultContainer">  
  9.         <register type="命名空间.接口类型1,命名空间" mapTo="命名空间.实现类型1,命名空间" />  
  10.         <register type="命名空间.接口类型2,命名空间" mapTo="命名空间.实现类型2,命名空间" />  
  11.       </container>  
  12.     </containers>  
  13.   </unity>  
  14. </configuration>  


配置的后台代码：

  1. UnityConfigurationSection configuration = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName)  
  2.             as UnityConfigurationSection;  
  3. configuration.Configure(container, "defaultContainer");  

可以通过方法ResolveAll来得到所有注册对象的实例：
var Instances = container.Resolve<IKiss>();

Martin Fowler在那篇著名的文章《Inversion of Control Containers and the Dependency Injection pattern》中将具体依赖注入划分为三种形式，即构造器注入、属性（设置）注入和接口注入,习惯将其划分为一种（类型）匹配和三种注入：

  • 类型匹配（Type Matching）：虽然我们通过接口（或者抽象类）来进行服务调用，但是服务本身还是实现在某个具体的服务类型中，这就需要某个类型注册机制来解决服务接口和服务类型之间的匹配关系；
  • 构造器注入（Constructor Injection）：IoC容器会智能地选择选择和调用适合的构造函数以创建依赖的对象。如果被选择的构造函数具有相应的参数，IoC容器在调用构造函数之前解析注册的依赖关系并自行获得相应参数对象；
  • 属性注入（Property Injection）：如果需要使用到被依赖对象的某个属性，在被依赖对象被创建之后，IoC容器会自动初始化该属性；
  • 方法注入（Method Injection）：如果被依赖对象需要调用某个方法进行相应的初始化，在该对象创建之后，IoC容器会自动调用该方法。

 

 

我们创建一个控制台程序，定义如下几个接口（IA、IB、IC和ID）和它们各自的实现类（A、B、C、D）。在类型A中定义了3个属性B、C和D，其类型分别为接口IB、IC和ID。其中属性B在构在函数中被初始化，以为着它会以构造器注入的方式被初始化；属性C上应用了DependencyAttribute特性，意味着这是一个需要以属性注入方式被初始化的依赖属性；属性D则通过方法Initialize初始化，该方法上应用了特性InjectionMethodAttribute，意味着这是一个注入方法在A对象被IoC容器创建的时候会被自动调用。

  1. public interface IA { }  
  2.     public interface IB { }  
  3.     public interface IC { }  
  4.     public interface ID { }  
  5.   
  6.     public class A : IA  
  7.     {  
  8.         public IB B { get; set; }  
  9.         [Dependency]  
  10.         public IC C { get; set; }  
  11.         public ID D { get; set; }  
  12.   
  13.         public A(IB b)  
  14.         {  
  15.             this.B = b;  
  16.         }  
  17.         [InjectionMethod]  
  18.         public void Initalize(ID d)  
  19.         {  
  20.             this.D = d;  
  21.         }  
  22.     }  
  23.     public class B : IB { }  
  24.     public class C : IC { }  
  25.     public class D : ID { }  


然后我们为该应用添加一个配置文件，并定义如下一段关于Unity的配置。这段配置定义了一个名称为defaultContainer的Unity容器，并在其中完成了上面定义的接口和对应实现类之间映射的类型匹配。

  1. <?xml version="1.0" encoding="utf-8" ?>  
  2. <configuration>  
  3.   <configSections>  
  4.     <section name="unity" type="Microsoft.Practices.Unity.Configuration.UnityConfigurationSection,Microsoft.Practices.Unity.Configuration"/>  
  5.   </configSections>  
  6.   <unity>  
  7.     <containers>  
  8.       <container name="defaultContainer">  
  9.         <register type="UnityDemo.IA,UnityDemo" mapTo="UnityDemo.A, UnityDemo"/>  
  10.         <register type="UnityDemo.IB,UnityDemo" mapTo="UnityDemo.B, UnityDemo"/>  
  11.         <register type="UnityDemo.IC,UnityDemo" mapTo="UnityDemo.C, UnityDemo"/>  
  12.         <register type="UnityDemo.ID,UnityDemo" mapTo="UnityDemo.D, UnityDemo"/>  
  13.       </container>  
  14.     </containers>  
  15.   </unity>  
  16. </configuration>  


最后在Main方法中创建一个代表IoC容器的UnityContainer对象，并加载配置信息对其进行初始化。然后调用它的泛型的Resolve方法创建一个实现了泛型接口IA的对象。最后将返回对象转变成类型A，并检验其B、C和D属性是否是空

  1. class Program  
  2.     {  
  3.         static void Main(string[] args)  
  4.         {  
  5.             UnityContainer container = new UnityContainer();  
  6.             UnityConfigurationSection configuration = ConfigurationManager.GetSection(UnityConfigurationSection.SectionName) as UnityConfigurationSection;  
  7.             configuration.Configure(container, "defaultContainer");  
  8.             A a = container.Resolve<IA>() as A;  
  9.             if (null!=a)  
  10.             {  
  11.                 Console.WriteLine("a.B==null?{0}",a.B==null?"Yes":"No");  
  12.                 Console.WriteLine("a.C==null?{0}", a.C == null ? "Yes" : "No");  
  13.                 Console.WriteLine("a.D==null?{0}", a.D == null ? "Yes" : "No");  
  14.             }  
  15.         }  
  16.     }  


从如下给出的执行结果我们可以得到这样的结论：通过Resolve<IA>方法返回的是一个类型为A的对象，该对象的三个属性被进行了有效的初始化。这个简单的程序分别体现了接口注入（通过相应的接口根据配置解析出相应的实现类型）、构造器注入（属性B）、属性注入（属性C）和方法注入（属性D）

  a.B == null ? No
 a.C == null ? No
 a.D == null ? No

转载于:https://www.cnblogs.com/wangchuang/p/5650911.html

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/349987.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

java中怎样验证重复文件_java – 如何在下载之前检查URL中的重复文件

java中怎样验证重复文件_java – 如何在下载之前检查URL中的重复文件

如果您有基本URL并存储具有相同文件名的文件.由于文件修改时间和If-Modified-Since HTTP Header,您可以询问服务器是否值得再次下载映像.File f new File();// the file to downloadHttpURLConnection con (HttpURLConnection) new URL("http://www.test.com/"f.ge…
阅读更多...
Jason是炮王

Jason是炮王

Jason是炮王 转载于:https://www.cnblogs.com/TankJam/p/11203636.html
阅读更多...
事件传递 java_将事件传递/发送到父组件？

事件传递 java_将事件传递/发送到父组件？

在Angular中&#xff0c;我可以创建一个发出动作的子组件&#xff1a;Component({...template: Click Me})export class ChildComponent {Output() onChildAction new EventEmitter();childAction() {this.onChildAction.emit();}}以及处理它的父组件 . 就像是&#xff1a;Com…
阅读更多...
mongodb身份验证_MongoDB身份验证

mongodb身份验证_MongoDB身份验证

mongodb身份验证我最近更新了Mongometer &#xff0c;使其更加灵活。 发布新版本后不久&#xff0c;其中一位用户通过在帖子中发表评论来反馈问题。 我启动了我的机器&#xff0c;打开了我的IDE&#xff0c;发现了问题&#xff0c;并在半小时内将修补程序推送到了github 。 这不…
阅读更多...
mysql列类型

mysql列类型

http://hi.baidu.com/b37798969/item/429fb25f838f1d3233e0a99b MySQL支持大量的列类型&#xff0c;它可以被分为3类&#xff1a;数字类型、日期和时间类型以及字符串(字符)类型。本节首先给出可用类型的一个概述&#xff0c;并且总结每个列类型的存储需求&#xff0c;然后提供…
阅读更多...
Java13的API_JAVA基础--JAVA API常见对象(其他API)13

Java13的API_JAVA基础--JAVA API常见对象(其他API)13

一、其他API1.System类system类中的方法和成员变量都是静态的&#xff0c; 不需要创建System对象就可以直接使用。1 /*2 * 演示System的使用3 */4 public classSystemDemo {5 public static voidmain(String[] args) {67 /*8 * System类中的静态成员变量&#xff1a; out 和 er…
阅读更多...
适用于Java开发人员的Elasticsearch：简介

适用于Java开发人员的Elasticsearch：简介

本文是我们学院课程的一部分&#xff0c;该课程的标题为Java开发人员的Elasticsearch教程 。 在本课程中&#xff0c;我们提供了一系列教程&#xff0c;以便您可以开发自己的基于Elasticsearch的应用程序。 我们涵盖了从安装和操作到Java API集成和报告的广泛主题。 通过我们简…
阅读更多...
人民邮电出版社图灵公司的两本SQL Server 2005图书诚征译者

人民邮电出版社图灵公司的两本SQL Server 2005图书诚征译者

人民邮电出版社图灵公司介绍&#xff08;来自http://www.turingbook.com/&#xff09; 北京图灵文化发展有限公司成立于2005年6月&#xff0c;由人民邮电出版社投资控股&#xff0c;以策划出版高质量的科技书籍为核心业务&#xff0c;主要出版领域包括计算机、电子电气、数学统…
阅读更多...
java容器类继承_JAVA容器 - weslie - OSCHINA - 中文开源技术交流社区

java容器类继承_JAVA容器 - weslie - OSCHINA - 中文开源技术交流社区

一、 数组1、数组是保存一组对象的最有效的方式。但数组有固定的尺寸而受限(p216)2、数组与其他种类的容器之间的区别有三方面&#xff1a;效率、类型和保存基本类型的能力。在Java中&#xff0c;数组是一种效率最高的存储和随机访问对象引用序列的方式。数组就是一个简单的线性…
阅读更多...
前端通信

前端通信

Node中的net模块提供的前端通信 H5提供的 webSocket 【 常用于 移动端 】pc端低版本浏览器使用 socket.io 通信- 服务端&#xff1a; 总的服务器 举例&#xff1a; 腾讯的qq服务器 1个整体- 客户端&#xff1a; 单个用户使用应用 举例&#xff1a; 每个人的qq 多个client.js 客…
阅读更多...
java定位线程阻塞_Arthas - 定位 Java 性能问题原来这么简单

java定位线程阻塞_Arthas - 定位 Java 性能问题原来这么简单

目录&#xff1a;一、Arthas 介绍二、Arthas 使用场景三、Arthas怎么使用四、Arthas 定位性能问题定位Java代码导致占用CPU高的问题线程死锁前言&#xff1a;在做性能测试的过程中&#xff0c;当遇到Java性能问题&#xff0c;比如CPU飙升&#xff0c;负载突高&#xff0c;内存溢…
阅读更多...
SVN 本地文件锁/服务端文件锁清除步骤

SVN 本地文件锁/服务端文件锁清除步骤

1.本地文件锁&#xff0c;直接cleanup&#xff0c;cleanup界面选择break locks即可 2.服务端文件锁&#xff0c;本地文件右击没有release lock或者break lock的选项时 方法1&#xff1a;右键&#xff0c;svn选择browser repo&#xff0c;找到该文件&#xff0c;右击&#xff0c…
阅读更多...
java 对象复活_Java对象复活

java 对象复活_Java对象复活

java 对象复活总览 收集覆盖了finalize&#xff08;&#xff09;的对象之后&#xff0c;将其添加到终结处理队列中&#xff0c;以在调用每个对象的finalize&#xff08;&#xff09;方法之后进行清理。 如果您复活了物体&#xff0c;会发生什么&#xff1f; 何时定案&#xff…
阅读更多...
a b和c 15 java_1011. A+B和C (15)

a b和c 15 java_1011. A+B和C (15)

给定区间[-231, 231]内的3个整数A、B和C&#xff0c;请判断AB是否大于C。输入格式&#xff1a;输入第1行给出正整数T(<10)&#xff0c;是测试用例的个数。随后给出T组测试用例&#xff0c;每组占一行&#xff0c;顺序给出A、B和C。整数间以空格分隔。输出格式&#xff1a;对…
阅读更多...
深入浅出《设计模式》之工厂模式（C++）

深入浅出《设计模式》之工厂模式（C++）

前言 模式介绍 在之前简单工厂模式中&#xff0c;我们介绍了简单工厂模式的缺陷是违背了开放-封闭原则。如果在面馆中添加了烤海参&#xff0c;那将会修改waiter工厂类。违背了类内封闭原则。 还以面馆为例&#xff0c;现在两种面&#xff0c;用一个服务员来卖就可以&#xff0…
阅读更多...
当心Spring缓慢的事务回调

当心Spring缓慢的事务回调

TL; DR 如果您的应用程序无法获得新的数据库连接&#xff0c;则重新启动ActiveMQ代理可能会有所帮助。 有兴趣吗 性能问题 几个月前&#xff0c;我们经历了生产中断。 大家都很熟悉&#xff0c;许多请求都失败了&#xff1a; java.sql.SQLTransientConnectionException: Hika…
阅读更多...
jmeter学习笔记（八-1）

jmeter学习笔记（八-1）

Jmeter中有较多需要参数化测试的地方&#xff1a; 1.从一个用户登录的接口获取登录后的token值&#xff0c;取值后用于后续接口调用 2.获取用户浏览后的cookies信息&#xff0c;需要用到HTTP Cookie 管理器来为同一线程组提供通用的cookies信息 Jmeter中通过${}形式来取参数值 …
阅读更多...
python 对象转dict_如何将python dict对象转换为java等效对象？

python 对象转dict_如何将python dict对象转换为java等效对象？

总是有jython。这里有一点来自this article&#xff0c;它提供了python/java的良好并排视图The Jython analogues to Javascollection classes are much moretightly integrated into the corelanguage, allowing for more concisedescriptions and useful functionality.For e…
阅读更多...
NOIP模拟测试5「星际旅行·砍树·超级树」

NOIP模拟测试5「星际旅行·砍树·超级树」

星际旅行 0分 瞬间爆炸。 考试的时候觉得这个题怎么这么难&#xff0c; 打个dp&#xff0c;可以被儿子贡献&#xff0c;可以被父亲贡献&#xff0c;还有自环&#xff0c;叶子节点连边可以贡献&#xff0c;非叶子也可以贡献&#xff0c;自环可以跑一回&#xff0c;自环可以跑两回…
阅读更多...
学java选i5还是i7_选笔记本电脑，到底CPU是要选i5还是i7

学java选i5还是i7_选笔记本电脑，到底CPU是要选i5还是i7

又到了一年毕业季&#xff0c;准备上大学的学生们肯定是摩拳擦掌&#xff0c;准备入手一台新的笔记本电脑。而我们在选购笔记本电脑的时候&#xff0c;经常会遇到不同的配置&#xff0c;比如说同一台笔记本电脑会有i5以及i7两个处理器可供选择&#xff0c;而价格往往相差一两千…
阅读更多...
最新文章

Copyright @ 2022~2023