Shulou(Shulou.com)06/03 Report--

What is the application of Effective Java in work? aiming at this problem, this article introduces the corresponding analysis and solution in detail, hoping to help more partners who want to solve this problem to find a more simple and feasible method.

If you have more than one constructor parameter, the constructor will be given priority.

When the class construction contains multiple parameters, the students will choose the JavaBeans mode. In this mode, you can call a no-parameter constructor to create the object, and then call the setter method to set the necessary and optional parameters. One of the most popular methods at present is to add @ Data annotation provided by Lombok to the class to automatically generate getter/setter, equals and other methods. But the JavaBeans mode cannot make classes immutable (immutable, see the section "minimizing deformability" for details). This requires developers to control the update of values and ensure thread safety and so on.

Recommended: Builder mode

The Builder mode calls a method like setter on the builder object to set the relevant parameters (similar to Proto Buffers). Finally, the immutable object (immutable object) is generated by calling the build method. One way to use the Builder pattern is to add the @ Builder annotation provided by Lombok to the class.

Application: API Request & Response

In the micro-service architecture, the request (request) and response (response) of the service often contain more parameters. In the process of processing the request, the author is often worried about misoperation to modify the content of the request. Therefore, the author tends to use Builder mode.

We can use the Builder schema to build this type of object. During the build process, if you need to introduce additional logic (e.g. If-else), you can return the Builder object first, and then call the build method.

Import lombok.Builder;/** request class * / @ Builderpublic class SampleRequest {private String paramOne; private int paramTwo; private boolean paramThree;} / * * response class * / @ Builderpublic class SampleResponse {private boolean success;} / * * service interface * / public interface SampleFacade {Result rpcOne (RequestParam) } / * * call * / public void testRpcOne () {SampleRequest request = SampleRequest.builder (). ParamOne ("one"). ParamTwo (2) .paramThree (true). Build (); Result response = sampleFacade.rpcOne (request);} 2 enhances non-instantiation capabilities through private constructors

Some classes, such as utility classes (utility class), contain only static fields and static methods. These classes should try to ensure that they are not instantiated to prevent misuse by users.

Recommended: privatized class constructor

To avoid misleading the user by thinking that the class is specifically designed for inheritance, we can privatize the constructor.

Public class SampleUtility {public static String getXXX () {return "test";} / * privatization constructor * / private SampleUtility () {}} / * * directly call methods * / public static void main (String [] args) {System.out.println (SampleUtility.getXXX ());} Class II and Interface 1 minimize the accessibility of classes and members

Try to make each class or member inaccessible to the outside world.

Recommendation: sometimes, in order to test, we have to turn some private (private) classes, interfaces, or members into package-level private (package-private). Here, I recommend that you use the @ VisiableForTesting annotation provided by Guava to indicate that this is to make the access level private at the package level for testing purposes, thus relaxing the restrictions.

Import com.google.common.annotations.VisibleForTesting;@VisibleForTesting (otherwise = VisibleForTesting.PRIVATE) String getXXX () {return "test";}

In addition, some partners recommend the PowerMock unit testing framework. PowerMock is an enhanced version of Mockito that enables Mock (simulation) of the private/static/final method. This is achieved by adding the @ PrepareForTest annotation.

Public class Utility {private static boolean isGreaterThan (int a, int b) {return a > b;} private Utility () {}} / * * Test Class * / import org.junit.Test;import org.junit.jupiter.api.Assertions;import org.junit.runner.RunWith;import org.powermock.core.classloader.annotations.PrepareForTest;import org.powermock.modules.junit4.PowerMockRunner;import org.powermock.reflect.Whitebox @ RunWith (PowerMockRunner.class) @ PrepareForTest ({Utility.class}) public class UtilityTest {@ Test public void test_privateIsGreaterThan_success () throws Exception {/ * * Test private isGreaterThan methods * / boolean result = Whitebox.invokeMethod (Utility.class, "isGreaterThan", 3,2); Assertions.assertTrue (result);}} 2 minimize deformability

An immutable class (immutable class) means that after the corresponding instance of the class is created, the value of its member variable cannot be changed. That is, all the information contained in the instance must be provided when the instance is created and fixed during the life cycle of the object.

Immutable classes generally use functional mode, that is, the corresponding method returns the result of a function, and the function operates on the Operand but does not modify it. Correspondingly, a more common approach is procedure or imperative. When using these methods, applying a procedure to their operands will cause its state to change.

As mentioned in the section "if you have more than one constructor parameter, give priority to the constructor", immutable objects are relatively simple, thread-safe, and have only one state. Developers who use this class do not need to do additional work to maintain constraint relationships. In addition, mutable objects can have arbitrarily complex states. If the mutator method (e.g. Update) is not described in detail, developers need to read the content of the method themselves. The author often spends more time figuring out which fields of the variable object are changed in a certain method, and whether the subsequent object operation will be affected after the end of the method. The author recommends that immutable objects be passed in, based on which a new immutable object is created with updated parameters. Although more objects are created, they are undeformable and more readable.

Recommended: Immutable class of Guava Collection

In daily development, the author tends to integrate the Immutable class (ImmutableList,ImmutableSet,ImmuableMap) and the function patterns mentioned above to implement the mutator class method.

Import static com.google.common.collect.ImmutableList.toImmutableList;import com.google.common.collect.ImmutableList;import com.google.common.collect.ImmutableMap;/** recommends * / private static final ImmutableMap SAMPLE_MAP = ImmutableMap.of ("One", 1, "Two", 2) / * * recommendation: make sure the original input list does not change * / public ImmutableList updateXXX (ImmutableList input) {return input.stream () .map (obj-> obj.setXXX (true)) .changes (toImmutableList ());} / * * not recommended: change input information * / public void filterXXX (List input) {input.forEach (obj-> obj.setXXX (true));} Trigeneric article 1 list takes precedence over array

Arrays are covariant, that is, Sub is a subtype of Super, so the array type Sub [] is a subtype of Super []; arrays are materialized, and their element type constraints are known and checked at run time. Generics are immutable and erasable (that is, their type information is reinforced at compile time and discarded at run time).

You need to be wary of the emergence of public static final arrays. It's probably a security breach!

Four methods

1 check the validity of the parameters

If an invalid parameter value is passed to a method, the method validation the parameter before performing complex, time-consuming logic, and it fails quickly and clearly throws the appropriate exception. If its parameters are not checked, all kinds of strange exceptions may occur later, and it is sometimes difficult to locate the cause.

The author believes that the API request provided by microservices should also follow this idea. That is, parameter verification is performed before the API request is processed by the service. Each request should be bound to the corresponding request validator. If the parameter value is invalid, a specific ClientException (e.g. IllegalArgumentException) is thrown.

2 carefully design the method signature

Choose the name of the method carefully:

The method of performing an action is usually named after a verb or verb phrase: createXXX,updateXXX,removeXXX,convertXXX,generateXXX

For methods that return a Boolean value, it usually starts with is: isValid,isLive,isEnabled

Avoid excessively long parameter lists: the target is four parameters, or less.

When there are too many parameters, the author will use Pair,Triple or helper class (e.g. Static member class)

Public class SampleListener {public ConsumeConcurrentlyStatus consumeMessage (String input) {SampleResult result = generateResult (input);.} private static SampleResult generateResult (String input) {...} / * * helper class * / private static class SampleResult {private boolean success; private List xxxList; private int count;}} 3 returns a zero-length array or collection instead of null

If a method returns null instead of a zero-length array or collection, the developer needs to add the check of! = null. Sometimes it is easy to forget the error and report to NullpointerException.

Speaking of which, the author would like to mention Optional. There is a lot of discussion about the use of Optional and null on the Internet. Optional allows the caller to continue a series of smooth method calls (e.g. Stream.getFirst (). OrElseThrow (()-> new MyFancyException (). The following is the author's views.

/ * * recommended: prompt that the return value may be empty. * / public Optional findFoo (String id); / * * neutral: slightly bulky * consider doSomething ("bar", null); * or overload doSomething ("bar"); and doSomething ("bar", "baz"); * / public Foo doSomething (String id, Optional barOptional); / * not recommended: contrary to the purpose of Optional design. * when the Optional value is default, there are generally three processing methods: 1) provide a substitute value; 2) call the method to provide a substitute value; 3) throw an exception * these handling methods can be handled at the beginning of the field or when the field is assigned. * * / public class Book {private List pages; private Optional index;} / * is not recommended: contrary to the purpose of Optional design. * if it is the default, it can be left out of the list. * * / List five general programming article 1 if you need an accurate answer, please avoid using float and double

Float and double types are mainly used in scientific and engineering calculations. They perform binary floating-point operations in order to provide a more accurate fast approximate calculation in the numerical range. However, they do not provide completely accurate results, especially for monetary calculations. It is not feasible for float or double to denote exactly 0.1.

If you need the system to record the decimal point, use BigDecimal.

2 basic types take precedence over basic packing types

Basic types (primitive) such as int, double, long and boolean. Each base type has a corresponding reference type, called boxed primitive type (boxed primitive), which corresponds to Integer, Double, Long, and Boolean. As mentioned in the book, the differences are as follows:

/ * * recommended * / public int sum (int a, int b) {return a + b;} / * * not recommended: unnecessary packing * / public Integer sum (Integer a, Integer b) {return a + b;}

If there is no special usage scenario, it is recommended that you always use the basic type. If you have to use the boxing primitive type, note the = = operation and NullPointerException exception. Usage scenarios for basic types of boxing:

As an element in the collection (e.g. Set)

Parameterized type e.g. ThreadLocal)

Reflected method call

Six exceptions 1 every exception thrown by each method must be documented

Always declare the checked exception separately and use the @ throws tag of Javadoc to accurately record the conditions under which each exception is thrown.

In my daily work, when I call the API of other groups, I sometimes find some unexpected exceptions. Good documentation can help API callers handle related exceptions better. Documentation can include the type of exception, the error code of the exception, and the description.

2 other

Some companies divide the exceptions generated by API into ClientException and ServerException. General ClientException (e.g. Invalid service request) is the exception handling caused by the caller's unusual call to API, but it is not in the main exception monitoring scope of the server. While ServerException (e.g. Database query timeout) is a problem caused by the server itself, which usually needs to be monitored.

Reference:

Bloch, Joshua. 2018. Effective Java, 3rd Edition

The answer to the question about the application of Effective Java at work is shared here. I hope the above content can be of some help to you. If you still have a lot of doubts to be solved, you can follow the industry information channel to learn more about it.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.