代码优化的一点总结

很多时候，为了赶项目进度，或是没有合适的代码review机制，再是每个程序员的水平高低各不相同。以下几点就是最近优化接口时做的一些调整。

1. 如果使用循环不停地去操作数据库，请把这个循环放在service层中，并且使用@Transactional，这样，就保证多次的数据库操作在一个事务中，不会不断地开启提交事务。不建议要放在controller层或action层中。
   举例代码如下：

    @Transactional
    @Override
    public List<Content> collectContents(Set<String> contentIds) {
        if (contentIds.isEmpty()) {
            return new ArrayList<>();
        }

        Integer[] ids = contentIds.stream()
                .map(id -> Integer.parseInt(id))
                .collect(Collectors.toList())
                .toArray(new Integer[contentIds.size()]);

        return dao.queryContentsInOne(ids);
    }

2. 如果需要获取redis的多个keys或批量操作时，推荐使用pipeline，减少网络通讯开销。
   举例代码如下：

Pipeline pipeline = jedis.pipelined();

        List<String> uIds = new LinkedList<>(followingUsers);
        for(String userId : uIds) {
            pipeline.exists(getFormatKeyStr(USER_CONTENT_ZSET, userId));
        }

Pipeline zaddPipeline = jedis.pipelined();
        if(Objects.nonNull(followingUpUserContents) && followingUpUserContents.size() > 0) {
            followingUpUserContents.forEach(content -> {
                zaddPipeline.zadd(getFormatKeyStr(USER_CONTENT_ZSET, content.getUser().getId()),
                        content.getSortDate().getTime(),
                        String.valueOf(content.getId()));
            });

            zaddPipeline.sync();
        }

3. 熟悉数据表的定义结构，每个字段的类型和长度，以及建立了哪些索引，哪些索引是必需的，哪些是可以去掉的，再是使用explain命令，来查看你要编写的sql语句是否使用了索引。

4. 在项目中遇到了OOM溢出，原因是原来Hibernate使用redis作为二级缓存，后因为redis需要大量的网络通信，后更换为Ehcache，结果就OOM了。其原因是Ehcache需要大量内存缓存查询结果，一开始分配的内存并不多。解决办法，增加内存。

5. 时刻记得null 和为空的情况，可以使用Optional来解决。
   举例代码如下：

package crazy;

import java.util.Optional;

class Company {
    private String name;
    private Optional<Office> office;

    public Company(String name, Optional<Office> office) {
        this.name = name;
        this.office = office;
    }

    public String getName() {
        return name;
    }

    public Optional<Office> getOffice() {
        return office;
    }
}

class Office {
    private String id;
    private Optional<Address> address;

    public Office(String id, Optional<Address> address) {
        this.id = id;
        this.address = address;
    }

    public String getId() {
        return id;
    }

    public Optional<Address> getAddress() {
        return address;
    }
}

class Address {
    private Optional<String> street;
    private Optional<String> city;

    public Address(Optional<String> street, Optional<String> city) {
        this.street = street;
        this.city = city;
    }

    public Optional<String> getStreet() {
        return street;
    }

    public Optional<String> getCity() {
        return city;
    }
}

public class OptionalDemo1 {

    public static void main(String[] args) {
        Optional<Address> address1 = Optional.of(new Address(Optional.ofNullable(null), Optional.of("New York")));
        Optional<Office> office1 = Optional.of(new Office("OF1", address1));
        Optional<Company> company1 = Optional.of(new Company("Door Never Closed", office1));

        // What is the street address of company1?
        // In which city company1 is located?
        Optional<Office> maybeOffice = company1.flatMap(Company::getOffice);
        Optional<Address> maybeAddress = office1.flatMap(Office::getAddress);
        Optional<String> maybeStreet = address1.flatMap(Address::getStreet);

        maybeStreet.ifPresent(System.out::println);
        if (maybeStreet.isPresent()) {
            System.out.println(maybeStreet.get());
        } else {
            System.out.println("Street not found.");
        }
        
        // shorter way
        String city = company1.flatMap(Company::getOffice)
                .flatMap(Office::getAddress)
                .flatMap(Address::getStreet)
                .orElse("City is not found.");
        
        System.out.println("City: " + city);
        
         // only print if city is not null
        company1.flatMap(Company::getOffice)
                .flatMap(Office::getAddress)
                .flatMap(Address::getCity)
                .ifPresent(System.out::println);

    }
}

6. 如果常见的优化手段并不明显，可以考虑使用临时表。

最重要的一点是：
写代码的时候，不要只盯着代码，要想你写的代码在内存或是在程序中是如何执行的。