java 快速生成有残午餐_写出优质Java代码的4个技巧

译者注:如果现在要求对你写的Java代码进行优化,那你会怎么做呢?作者在本文介绍了可以提高系统性能以及代码可读性的四种方法,如果你对此感兴趣,就让我们一起来看看吧。以下为译文。

本文我们将介绍一些有助于解决常见问题的通用设计策略和目标实现技术,即:

只做有目的性的优化

常量尽量使用枚举

重新定义类里面的equals()方法

尽量多使用多态性

值得注意的是,本文中描述的技术并不是适用于所有情况。另外这些技术应该什么时候使用以及在什么地方使用,都是需要使用者经过深思熟虑的。

1 .只做有目的性的优化

大型软件系统肯定非常关注性能问题。虽然我们希望能够写出最高效的代码,但很多时候,如果想对代码进行优化,我们却无从下手。例如,下面的这段代码会影响到性能吗?

public void processIntegers(List integers) {

for (Integer value: integers) {

for (int i = integers.size() - 1; i >= 0; i--) {

value += integers.get(i);

}

}

}

这就得视情况而定了。上面这段代码可以看出它的处理算法是O(n³)(使用大O符号),其中n是list集合的大小。如果n只有5,那么就不会有问题,只会执行25次迭代。但如果n是10万,那可能会影响性能了。请注意,即使这样我们也不能判定肯定会有问题。尽管此方法需要执行10亿次逻辑迭代,但会不会对性能产生影响仍然有待讨论。

例如,假设客户端是在它自己的线程中执行这段代码,并且异步等待计算完成,那么它的执行时间有可能是可以接受的。同样,如果系统部署在了生产环境上,但是没有客户端进行调用,那我们根本没必要去对这段代码进行优化,因为压根就不会消耗系统的整体性能。事实上,优化性能以后系统会变得更加复杂,悲剧的是系统的性能却没有因此而提高。

最重要的是天下没有免费的午餐,因此为了降低代价,我们通常会通过类似于缓存、循环展开或预计算值这类技术去实现优化,这样反而增加了系统的复杂性,也降低了代码的可读性。如果这种优化可以提高系统的性能,那么即使变得复杂,那也是值得的,但是做决定之前,必须首先知道这两条信息:

性能要求是什么

性能瓶颈在哪里

首先我们需要清楚地知道性能要求是什么。如果最终是在要求以内,并且最终用户也没有提出什么异议,那么就没有必要进行性能优化。但是,当添加了新功能或者系统的数据量达到一定规模以后就必须进行优化了,否则可能会出现问题。

在这种情况下,不应该靠直觉,也不应该依靠检查。因为即使是像Martin Fowler这样有经验的开发人员也容易做一些错误的优化,正如在重构(第70页)一文中解释的那样:

如果分析了足够多的程序以后,你会发现关于性能的有趣之处在于,大部分时间都浪费在了系统中的一小部分代码中里面。如果对所有代码进行了同样的优化,那么最终结果就是浪费了90%的优化,因为优化过以后的代码运行得频率并不多。因为没有目标而做的优化所耗费的时间,都是在浪费时间。

作为一名身经百战的开发人员,我们应该认真对待这一观点。第一次猜测不仅没有提高系统的性能,而且90%的开发时间完全是浪费了。相反,我们应该在生产环境(或者预生产环境中)执行常见用例,并找出在执行过程中是哪部分在消耗系统资源,然后对系统进行配置。例如消耗大部分资源的代码只占了10%,那么优化其余90%的代码就是浪费时间。

根据分析结果,要想使用这些知识,我们应该从最常见的情况入手。因为这将确保实际付出的努力最终是可以提高系统的性能。每次优化后,都应该重复分析步骤。因为这不仅可以确保系统的性能真的得到了改善,也可以看出再对系统进行优化后,性能瓶颈是在哪个部分(因为解决完一个瓶颈以后,其它瓶颈可能消耗系统更多的整体资源)。需要注意的是,在现有瓶颈中花费的时间百分比很可能会增加,因为剩下的瓶颈是暂时不变的,而且随着目标瓶颈的消除,整个执行时间应该会减少。

尽管在Java系统中想要对概要文件进行全面检查需要很大的容量,但是还是有一些很常见的工具可以帮助发现系统的性能热点,这些工具包括JMeter、AppDynamics和YourKit。另外,还可以参见DZone的性能监测指南,获取更多关于Java程序性能优化的信息。

虽然性能是许多大型软件系统一个非常重要的组成部分,也成为产品交付管道中自动化测试套件的一部分,但是还是不能够盲目的且没有目的的进行优化。相反,应该对已经掌握的性能瓶颈进行特定的优化。这不仅可以帮助我们避免增加了系统的复杂性,而且还让我们少走弯路,不去做那些浪费时间的优化。

2.常量尽量使用枚举

需要用户列出一组预定义或常量值的场景有很多,例如在web应用程序中可能遇到的HTTP响应代码。最常见的实现技术之一是新建类,该类里面有很多静态的final类型的值,每个值都应该有一句注释,描述该值的含义是什么:

public class HttpResponseCodes {

public static final int OK = 200;

public static final int NOT_FOUND = 404;

public static final int FORBIDDEN = 403;

}

if (getHttpResponse().getStatusCode() == HttpResponseCodes.OK) {

// Do something if the response code is OK

}

能够有这种思路就已经非常好了,但这还是有一些缺点:

没有对传入的整数值进行严格的校验

由于是基本数据类型,因此不能调用状态代码上的方法

在第一种情况下只是简单的创建了一个特定的常量来表示特殊的整数值,但并没有对方法或变量进行限制,因此使用的值可能会超出定义的范围。例如:

public class HttpResponseHandler {

public static void printMessage(int statusCode) {

System.out.println("Recieved status of " + statusCode);

}

}

HttpResponseHandler.printMessage(15000);

尽管15000并不是有效的HTTP响应代码,但是由于服务器端也没有限制客户端必须提供有效的整数。在第二种情况下,我们没有办法为状态代码定义方法。例如,如果想要检查给定的状态代码是否是一个成功的代码,那就必须定义一个单独的函数:

public class HttpResponseCodes {

public static final int OK = 200;

public static final int NOT_FOUND = 404;

public static final int FORBIDDEN = 403;

public static boolean isSuccess(int statusCode) {

return statusCode >= 200 && statusCode < 300;

}

}

if (HttpResponseCodes.isSuccess(getHttpResponse().getStatusCode())) {

// Do something if the response code is a success code

}

为了解决这些问题,我们需要将常量类型从基本数据类型改为自定义类型,并只允许自定义类的特定对象。这正是Java枚举(enum)的用途。使用enum,我们可以一次性解决这两个问题:

public enum HttpResponseCodes {

OK(200),

FORBIDDEN(403),

NOT_FOUND(404);

private final int code;

HttpResponseCodes(int code) {

this.code = code;

}

public int getCode() {

return code;

}

public boolean isSuccess() {

return code >= 200 && code < 300;

}

}

if (getHttpResponse().getStatusCode().isSuccess()) {

// Do something if the response code is a success code

}

同样,现在还可以要求在调用方法的时候提供必须有效的状态代码:

public class HttpResponseHandler {

public static void printMessage(HttpResponseCode statusCode) {

System.out.println("Recieved status of " + statusCode.getCode());

}

}

HttpResponseHandler.printMessage(HttpResponseCode.OK);

值得注意的是,举这个例子事项说明如果是常量,则应该尽量使用枚举,但并不是说什么情况下都应该使用枚举。在某些情况下,可能希望使用一个常量来表示某个特殊值,但是也允许提供其它的值。例如,大家可能都知道圆周率,我们可以用一个常量来捕获这个值(并重用它):

public class NumericConstants {

public static final double PI = 3.14;

public static final double UNIT_CIRCLE_AREA = PI * PI;

}

public class Rug {

private final double area;

public class Run(double area) {

this.area = area;

}

public double getCost() {

return area * 2;

}

}

// Create a carpet that is 4 feet in diameter (radius of 2 feet)

Rug fourFootRug = new Rug(2 * NumericConstants.UNIT_CIRCLE_AREA);

因此,使用枚举的规则可以归纳为:

当所有可能的离散值都已经提前知道了,那么就可以使用枚举

再拿上文中所提到的HTTP响应代码为例,我们可能知道HTTP状态代码的所有值(可以在RFC 7231中找的到,它定义了HTTP 1.1协议)。因此使用了枚举。在计算圆周率的情况下,我们不知道关于圆周率的所有可能值(任何可能的double都是有效的),但同时又希望为圆形的rugs创建一个常量,使计算更容易(更容易阅读);因此定义了一系列常量。

如果不能提前知道所有可能的值,但是又希望包含每个值的字段或方法,那么最简单的方法就是可以新建一个类来表示数据。尽管没有说过什么场景应该绝对不用枚举,但要想知道在什么地方、什么时间不使用枚举的关键是提前意识到所有的值,并且禁止使用其他任何值。

3.重新定义类里面的equals()方法

对象识别可能是一个很难解决的问题:如果两个对象在内存中占据相同的位置,那么它们是相同的吗?如果它们的id相同,它们是相同的吗?或者如果所有的字段都相等呢?虽然每个类都有自己的标识逻辑,但是在系统中有很多西方都需要去判断是否相等。例如,有如下的一个类,表示订单购买…

public class Purchase {

private long id;

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

}

……就像下面写的这样,代码中肯定有很多地方都是类似于的:

Purchase originalPurchase = new Purchase();

Purchase updatedPurchase = new Purchase();

if (originalPurchase.getId() == updatedPurchase.getId()) {

// Execute some logic for equal purchases

}

这些逻辑调用的越多(反过来,违背了DRY原则),Purchase类的身份信息也会变得越来越多。如果出于某种原因,更改了Purchase类的身份逻辑(例如,更改了标识符的类型),则需要更新标识逻辑所在的位置肯定也非常多。

我们应该在类的内部初始化这个逻辑,而不是通过系统将Purchase类的身份逻辑进行过多的传播。乍一看,我们可以创建一个新的方法,比如isSame,这个方法的入参是一个Purchase对象,并对每个对象的id进行比较,看看它们是否相同:

public class Purchase {

private long id;

public boolean isSame(Purchase other) {

return getId() == other.gerId();

}

}

虽然这是一个有效的解决方案,但是忽略了Java的内置功能:使用equals方法。Java中的每个类都是继承了Object类,虽然是隐式的,因此同样也就继承了equals方法。默认情况下,此方法将检查对象标识(内存中相同的对象),如JDK中的对象类定义(version 1.8.0_131)中的以下代码片段所示:

public boolean equals(Object obj) {

return (this == obj);

}

这个equals方法充当了注入身份逻辑的自然位置(通过覆盖默认的equals实现):

public class Purchase {

private long id;

public long getId() {

return id;

}

public void setId(long id) {

this.id = id;

}

@Override

public boolean equals(Object other) {

if (this == other) {

return true;

}

else if (!(other instanceof Purchase)) {

return false;

}

else {

return ((Purchase) other).getId() == getId();

}

}

}

虽然这个equals方法看起来很复杂,但由于equals方法只接受类型对象的参数,所以我们只需要考虑三个案例:

另一个对象是当前对象(即originalPurchase.equals(originalPurchase)),根据定义,它们是同一个对象,因此返回true

另一个对象不是Purchase对象,在这种情况下,我们无法比较Purchase的id,因此,这两个对象不相等

其他对象不是同一个对象,但却是Purchase的实例,因此,是否相等取决于当前Purchase的id和其他Purchase是否相等

现在可以重构我们之前的条件,如下:

Purchase originalPurchase = new Purchase();

Purchase updatedPurchase = new Purchase();

if (originalPurchase.equals(updatedPurchase)) {

// Execute some logic for equal purchases

}

除了可以在系统中减少复制,重构默认的equals方法还有一些其它的优势。例如,如果构造一个Purchase对象列表,并检查列表是否包含具有相同ID(内存中不同对象)的另一个Purchase对象,那么我们就会得到true值,因为这两个值被认为是相等的:

List purchases = new ArrayList<>();

purchases.add(originalPurchase);

purchases.contains(updatedPurchase); // True

通常,无论在什么地方,如果需要判断两个类是否相等,则只需要使用重写过的equals方法就可以了。如果希望使用由于继承了Object对象而隐式具有的equals方法去判断相等性,我们还可以使用= =操作符,如下:

if (originalPurchase == updatedPurchase) {

// The two objects are the same objects in memory

}

还需要注意的是,当equals方法被重写以后,hashCode方法也应该被重写。有关这两种方法之间关系的更多信息,以及如何正确定义hashCode方法,请参见此线程。

正如我们所看到的,重写equals方法不仅可以将身份逻辑在类的内部进行初始化,并在整个系统中减少了这种逻辑的扩散,它还允许Java语言对类做出有根据的决定。

4.尽量多使用多态性

对于任何一门编程语言来说,条件句都是一种很常见的结构,而且它的存在也是有一定原因的。因为不同的组合可以允许用户根据给定值或对象的瞬时状态改变系统的行为。假设用户需要计算各银行账户的余额,那么就可以开发出以下的代码:

public enum BankAccountType {

CHECKING,

SAVINGS,

CERTIFICATE_OF_DEPOSIT;

}

public class BankAccount {

private final BankAccountType type;

public BankAccount(BankAccountType type) {

this.type = type;

}

public double getInterestRate() {

switch(type) {

case CHECKING:

return 0.03; // 3%

case SAVINGS:

return 0.04; // 4%

case CERTIFICATE_OF_DEPOSIT:

return 0.05; // 5%

default:

throw new UnsupportedOperationException();

}

}

public boolean supportsDeposits() {

switch(type) {

case CHECKING:

return true;

case SAVINGS:

return true;

case CERTIFICATE_OF_DEPOSIT:

return false;

default:

throw new UnsupportedOperationException();

}

}

}

虽然上面这段代码满足了基本的要求,但是有个很明显的缺陷:用户只是根据给定帐户的类型决定系统的行为。这不仅要求用户每次要做决定之前都需要检查账户类型,还需要在做出决定时重复这个逻辑。例如,在上面的设计中,用户必须在两种方法都进行检查才可以。这就可能会出现失控的情况,特别是接收到添加新帐户类型的需求时。

我们可以使用多态来隐式地做出决策,而不是使用账户类型用来区分。为了做到这一点,我们将BankAccount的具体类转换成一个接口,并将决策过程传入一系列具体的类,这些类代表了每种类型的银行帐户:

public interface BankAccount {

public double getInterestRate();

public boolean supportsDeposits();

}

public class CheckingAccount implements BankAccount {

@Override

public double getIntestRate() {

return 0.03;

}

@Override

public boolean supportsDeposits() {

return true;

}

}

public class SavingsAccount implements BankAccount {

@Override

public double getIntestRate() {

return 0.04;

}

@Override

public boolean supportsDeposits() {

return true;

}

}

public class CertificateOfDepositAccount implements BankAccount {

@Override

public double getIntestRate() {

return 0.05;

}

@Override

public boolean supportsDeposits() {

return false;

}

}

这不仅将每个帐户特有的信息封装到了到自己的类中,而且还支持用户可以在两种重要的方式中对设计进行变化。首先,如果想要添加一个新的银行帐户类型,只需创建一个新的具体类,实现了BankAccount的接口,给出两个方法的具体实现就可以了。在条件结构设计中,我们必须在枚举中添加一个新值,在两个方法中添加新的case语句,并在每个case语句下插入新帐户的逻辑。

其次,如果我们希望在BankAccount接口中添加一个新方法,我们只需在每个具体类中添加新方法。在条件设计中,我们必须复制现有的switch语句并将其添加到我们的新方法中。此外,我们还必须在每个case语句中添加每个帐户类型的逻辑。

在数学上,当我们创建一个新方法或添加一个新类型时,我们必须在多态和条件设计中做出相同数量的逻辑更改。例如,如果我们在多态设计中添加一个新方法,我们必须将新方法添加到所有n个银行帐户的具体类中,而在条件设计中,我们必须在我们的新方法中添加n个新的case语句。如果我们在多态设计中添加一个新的account类型,我们必须在BankAccount接口中实现所有的m数,而在条件设计中,我们必须向每个m现有方法添加一个新的case语句。

虽然我们必须做的改变的数量是相等的,但变化的性质却是完全不同的。在多态设计中,如果我们添加一个新的帐户类型并且忘记包含一个方法,编译器会抛出一个错误,因为我们没有在我们的BankAccount接口中实现所有的方法。在条件设计中,没有这样的检查,以确保每个类型都有一个case语句。如果添加了新类型,我们可以简单地忘记更新每个switch语句。这个问题越严重,我们就越重复我们的switch语句。我们是人类,我们倾向于犯错误。因此,任何时候,只要我们可以依赖编译器来提醒我们错误,我们就应该这么做。

关于这两种设计的第二个重要注意事项是它们在外部是等同的。例如,如果我们想要检查一个支票帐户的利率,条件设计就会类似如下:

BankAccount checkingAccount = new BankAccount(BankAccountType.CHECKING);

System.out.println(checkingAccount.getInterestRate()); // Output: 0.03

相反,多态设计将类似如下:

BankAccount checkingAccount = new CheckingAccount();

System.out.println(checkingAccount.getInterestRate()); // Output: 0.03

从外部的角度来看,我们只是在BankAccount对象上调用getintereUNK()。如果我们将创建过程抽象为一个工厂类的话,这将更加明显:

public class ConditionalAccountFactory {

public static BankAccount createCheckingAccount() {

return new BankAccount(BankAccountType.CHECKING);

}

}

public class PolymorphicAccountFactory {

public static BankAccount createCheckingAccount() {

return new CheckingAccount();

}

}

// In both cases, we create the accounts using a factory

BankAccount conditionalCheckingAccount = ConditionalAccountFactory.createCheckingAccount();

BankAccount polymorphicCheckingAccount = PolymorphicAccountFactory.createCheckingAccount();

// In both cases, the call to obtain the interest rate is the same

System.out.println(conditionalCheckingAccount.getInterestRate()); // Output: 0.03

System.out.println(polymorphicCheckingAccount.getInterestRate()); // Output: 0.03

将条件逻辑替换成多态类是非常常见的,因此已经发布了将条件语句重构为多态类的方法。这里就有一个简单的例子。此外,马丁·福勒(Martin Fowler)的《重构》(p . 255)也描述了执行这个重构的详细过程。

就像本文中的其他技术一样,对于何时执行从条件逻辑转换到多态类,没有硬性规定。事实上,如论在何种情况下我们都是不建议使用。在测试驱动的设计中:例如,Kent Beck设计了一个简单的货币系统,目的是使用多态类,但发现这使设计过于复杂,于是便将他的设计重新设计成一个非多态风格。经验和合理的判断将决定何时是将条件代码转换为多态代码的合适时间。

结束语

作为程序员,尽管平常所使用的常规技术可以解决大部分的问题,但有时我们应该打破这种常规,主动需求一些创新。毕竟作为一名开发人员,扩展自己知识面的的广度和深度,不仅能让我们做出更明智的决定,也能让我们变得越来越聪明。

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

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

相关文章

在Kubernetes上运行区块链服务(BaaS)

本文是在2018年11月15日由Linux基金会CNCF主办的KubeCon & CloudNativeCon China 2018大会的“Running Blockchain as a Service (BaaS) on Kubernetes”演讲内容基础上整理而成&#xff0c;从技术上介绍了阿里云如何将基于区块链Hyperledger Fabric的BaaS和容器集群技术Ku…

RabbitMQ 镜像集群之同步策略_专栏讲解

文章目录一、 基础知识汲取1.1. 镜像集群简述1.2. 策略参数说明1.3. 策略案例二、HA mode 同步方式2.1. 参数说明2.2. 案例2.3. 命令终端形式2.4. MQ管控台设置2.5. 队列同步2.5. 优缺点三、Ha async mode 同步方式&#xff08;推荐使用&#xff09;3.1. 参数说明3.2. 案例3.3.…

bug要改一天?

大家应该都听过下面的一个段子~女生&#xff1a;亲爱的&#xff0c;我来亲戚了男生&#xff1a;多喝热水......女生&#xff1a;我好像要感冒了&#xff0c;亲爱的~男生&#xff1a;多喝热水......女生&#xff1a;我现在好难受哦&#xff0c;快撑不下去了男生&#xff1a;多喝…

新手也能看懂,消息队列其实很简单

本文内容思维导图&#xff1a; 消息队列其实很简单 “RabbitMQ&#xff1f;”“Kafka&#xff1f;”“RocketMQ&#xff1f;”...在日常学习与开发过程中&#xff0c;我们常常听到消息队列这个关键词。我也在我的多篇文章中提到了这个概念。可能你是熟练使用消息队列的老手&am…

java注册是什么意思_springcloud注册中心是什么意思?有什么作用?

可能我们都知道现如今java分布式微服务的流行程度&#xff0c;那么你了解过springcloud的有关内容吗?例如&#xff0c;springcloud中的注册中心是什么?用在何处?注册中心其实就是服务发现的核心。它主要保存了各个可用服务实例的网络地址(指IP Address和Port)。服务注册中心…

如何去设计前端框架能力?星巴克消息开放项目从0到1,从点到面的思考

本文由淘宝前端工程师罗嗣分享&#xff0c;主要讲述了作者在星巴克消息开放项目中的总结和思考&#xff0c;希望对大家有帮助&#xff0c;让业务分享更加有价值。 从满足星巴克项目需求单点出发&#xff0c;发散到从点到面的思考。从而总结了自己思考的基本流程&#xff08;方法…

如何在springboot中使用PageHelper分页插件

文章目录1. pom依赖2. yml3. 实体类4. mapper映射文件4. mapper接口5. service接口6. 实现类7. controller8. 浏览器验证使用思路&#xff1a; 1.引入myabtis和pagehelper依赖 2.yml中配置mybatis扫描和实体类 3. 这2行代码 pageNum&#xff1a;当前第几页 pageNum&#xff1a;…

6.6折票仅剩3天 | BDTC 2019全日程公布,哪些是你感兴趣的话题?

2019年12月5-7日&#xff0c;由中国计算机学会主办&#xff0c;CCF 大数据专家委员会承办&#xff0c;CSDN、中科天玑数据科技股份有限公司协办的中国大数据技术大会&#xff08;BDTC 2019&#xff09;将于北京长城饭店隆重举行。届时&#xff0c;超过百位顶尖技术专家将齐聚于…

云栖专辑| 阿里毕玄:程序员的成长路线

2018年12月20日&#xff0c;云栖社区3周岁生日。阿里巴巴常说“晴天修屋顶”&#xff0c;所以我们特别策划了这个专辑——分享给开发者们20个阿里故事&#xff0c;50本书籍。第一位是林昊&#xff08;毕玄&#xff09;。 在这篇《程序员的成长路线》里&#xff0c;阿里基础设施…

java线程条件变量_使用条件变量(多线程笔记)

条件变量属性&#xff1a;使用条件变量可以以原子方式阻塞线程&#xff0c;知道某个特定条件为真为止。条件变量始终与互斥锁一起使用。使用条件变量&#xff0c;线程可以以原子方式阻塞&#xff0c;知道满足某个条件为止。对掉件的测试时在互斥锁的保护下进行的。如果条件为假…

用PyTorch创建一个图像分类器?So easy!(Part 2)

在第一部分中&#xff0c;我们知道了为什么以及如何加载预先训练好的神经网络&#xff0c;我们可以用自己的分类器代替已有神经网络的分类器。那么&#xff0c;在这篇文章中&#xff0c;我们将学习如何训练分类器。 训练分类器 首先&#xff0c;我们需要为分类器提供待分类的…

涨姿势,一个通信项目从开始到结束,原来还包括这些工作

戳蓝字“CSDN云计算”关注我们哦&#xff01;作者 | 小枣君责编 | 阿秃本月12日&#xff0c;中国移动31个省的通信工程设计与可行性研究集采正式启动。这次集采规模庞大&#xff0c;涵盖了无线网(5G、FDD、NB等)、核心网、承载网、支撑网等专业方向&#xff0c;预估基本规模超4…

spring项目链接RabbitMQ集群

文章目录1.pom2. spring-rabbitmq-producer.xml3. spring-rabbitmq-consumer.xml4. rabbitmq.properties1.pom <!--spring整合rabbitmq--><dependency><groupId>com.rabbitmq</groupId><artifactId>amqp-client</artifactId><version&g…

听说支付宝有一个“疯起来连自己都打”的项目

小蚂蚁说&#xff1a; 自古红蓝出CP&#xff0c;在蚂蚁金服就有这样两支“相爱相杀”的队伍——红军和蓝军。蓝军是进攻方&#xff0c;主要职责是挖掘系统的弱点并发起“真实”的攻击&#xff0c;俗称“找茬”&#xff1b;红军则是防守方&#xff0c;其防控体系建设中的实时核…

蚂蚁金服红蓝军技术攻防演练究竟有多“狠”

如果一个技术团队不干别的&#xff0c;专门“搞破坏”&#xff0c;这是一种怎样的存在&#xff1f;这真的不是“天方夜谭”&#xff0c;在支付宝确实有这么一支队伍——技术蓝军。蓝军的任务就是不断地攻击和进攻&#xff0c;而防守方则是技术红军。在支付宝&#xff0c;蓝军从…

java虚拟机中xms_java JVM虚拟机选项: Xms Xmx PermSize MaxPermSize 区别

java虽然是自动回收内存&#xff0c;但是应用程序&#xff0c;尤其服务器程序最好根据业务情况指明内存分配限制。否则可能导致应用程序宕掉。举例说明含义&#xff1a;-Xms128m表示JVM Heap(堆内存)最小尺寸128MB&#xff0c;初始分配-Xmx512m表示JVM Heap(堆内存)最大允许的尺…

linux 目录挂载

背景&#xff1a;文件服务器200G&#xff0c;日志大小已经超过200G&#xff0c;使用率达到100% 解决方案&#xff1a; nas挂载&#xff0c;申请的挂载磁盘空间1T 挂载声明&#xff1a; 当执行挂载命令后&#xff0c;本地挂载的原目录下面是空的 只有解挂后&#xff0c;以前目录…

阿里巴巴在内蒙古旱区试水物联网灌溉技术,一年省出1.5个西湖

阿里巴巴正用物联网技术解决干旱地区的灌溉问题&#xff0c;通过搭建农业物联网平台&#xff0c;全面监测农作物的生长状态&#xff0c;从而匹配最节约的灌溉方案。12月19日试验区研究人员得出预测结果&#xff1a;一年可以省出1.5个西湖的水。 一直以来干旱是困扰人类的重要环…

不少人暗搓搓的准备春招了,我有一些好东东和招聘信息给你

2017远去了&#xff01;2018远去了&#xff01;&#xff01;很快&#xff0c;2019 也要远去了&#xff01;&#xff01;&#xff01;被各种裁员和寒冬扎心的老铁&#xff0c;你还在犹豫什么&#xff1f;赶紧学习起来&#xff0c;找份靠谱的工作吧&#xff01;找工作这件事&…

网易考拉在服务化改造方面的实践

导读&#xff1a; 网易考拉&#xff08;以下简称考拉&#xff09;是网易旗下以跨境业务为主的综合型电商&#xff0c;自2015年1月9日上线公测后&#xff0c;业务保持了高速增长&#xff0c;这背后离不开其技术团队的支撑。微服务化是电商IT架构演化的必然趋势&#xff0c;网易…