1, mediante la validación de Hibernate, Spring parámetros válidos recibidos en el extremo delantero de la comprobación de los datos, if-else reducir código redundante. PS: prestar atención a la gestión de excepciones.
2, Manual de Ali Baba Java Developer fácil pasar por alto:
1)、各层命名规约：
A)、Service/DAO 层方法命名规约
1.1)、获取单个对象的方法用 get 做前缀。
1.2)、获取多个对象的方法用 list 做前缀，复数形式结尾如：listObjects。
1.3)、获取统计值的方法用 count 做前缀。
1.4)、插入的方法用 save/insert 做前缀。
1.5)、删除的方法用 remove/delete 做前缀。
1.6)、修改的方法用 update 做前缀。
B)、领域模型命名规约
1.1)、数据对象：xxxDO，xxx 即为数据表名。
1.2)、数据传输对象：xxxDTO，xxx 为业务领域相关的名称。
1.3)、展示对象：xxxVO，xxx 一般为网页名称。
1.4)、POJO 是 DO/DTO/BO/VO 的统称，禁止命名成 xxxPOJO。
2)、关于基本数据类型与包装数据类型的使用标准如下：
2.1)、【强制】所有的 POJO 类属性必须使用包装数据类型。
2.2)、【强制】RPC 方法的返回值和参数必须使用包装数据类型。
2.3)、【推荐】所有的局部变量使用基本数据类型。
说明：POJO 类属性没有初值是提醒使用者在需要使用时，必须自己显式地进行赋值，任何
NPE 问题，或者入库检查，都由使用者来保证。
正例：数据库的查询结果可能是 null，因为自动拆箱，用基本数据类型接收有 NPE 风险。
反例：比如显示成交总额涨跌情况，即正负 x%，x 为基本数据类型，调用的 RPC 服务，调用
不成功时，返回的是默认值，页面显示为 0%，这是不合理的，应该显示成中划线。所以包装
数据类型的 null 值，能够表示额外的信息，如：远程调用失败，异常退出。
3)、【强制】序列化类新增属性时，请不要修改 serialVersionUID 字段，避免反序列失败；如
果完全不兼容升级，避免反序列化混乱，那么请修改 serialVersionUID 值。
说明：注意 serialVersionUID 不一致会抛出序列化运行时异常。
4)、【强制】POJO 类必须写 toString 方法。使用 IDE 中的工具：source> generate toString
时，如果继承了另一个 POJO 类，注意在前面加一下 super.toString。
说明：在方法执行抛出异常时，可以直接调用 POJO 的 toString()方法打印其属性值，便于排
查问题。
5)、【强制】使用集合转数组的方法，必须使用集合的 toArray(T[] array)，传入的是类型完全
一样的数组，大小就是 list.size()。
说明：使用 toArray 带参方法，入参分配的数组空间不够大时，toArray 方法内部将重新分配
内存空间，并返回新数组地址；如果数组元素个数大于实际所需，下标为[ list.size() ]
的数组元素将被置为 null，其它数组元素保持原值，因此最好将方法入参数组大小定义与集
合元素个数一致。
正例：
List<String> list = new ArrayList<String>(2);
list.add("guan");
list.add("bao");
String[] array = new String[list.size()];
array = list.toArray(array);
反例：直接使用 toArray 无参方法存在问题，此方法返回值只能是 Object[]类，若强转其它
类型数组将出现 ClassCastException 错误。
6)、【强制】使用工具类 Arrays.asList()把数组转换成集合时，不能使用其修改集合相关的方
法，它的 add/remove/clear 方法会抛出 UnsupportedOperationException 异常。
说明：asList 的返回对象是一个 Arrays 内部类，并没有实现集合的修改方法。Arrays.asList
体现的是适配器模式，只是转换接口，后台的数据仍是数组。
String[] str = new String[] { "you", "wu" };
List list = Arrays.asList(str);
第一种情况：list.add("yangguanbao"); 运行时异常。
第二种情况：str[0] = "gujin"; 那么 list.get(0)也会随之修改。
7)、【强制】不要在 foreach 循环里进行元素的 remove/add 操作。remove 元素请使用 Iterator
方式，如果并发操作，需要对 Iterator 对象加锁。
正例：
List<String> list = new ArrayList<>();
list.add("1");
list.add("2");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
String item = iterator.next();
if (删除元素的条件) {
iterator.remove();
}
}
反例：
for (String item : list) {
if ("1".equals(item)) {
list.remove(item);
}
}
说明：以上代码的执行结果肯定会出乎大家的意料，那么试一下把“1”换成“2”，会是同样的
结果吗？
8)、【推荐】集合泛型定义时，在 JDK7 及以上，使用 diamond 语法或全省略。
说明：菱形泛型，即 diamond，直接使用<>来指代前边已经指定的类型。
正例：
// <> diamond 方式
HashMap<String, String> userCache = new HashMap<>(16);
// 全省略方式
ArrayList<User> users = new ArrayList(10);
9)、【推荐】集合初始化时，指定集合初始值大小。
说明：HashMap 使用 HashMap(int initialCapacity) 初始化。
正例：initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即 loader
factor）默认为 0.75，如果暂时无法确定初始值大小，请设置为 16（即默认值）。
反例：HashMap 需要放置 1024 个元素，由于没有设置容量初始大小，随着元素不断增加，容
量 7 次被迫扩大，resize 需要重建 hash 表，严重影响性能。
10)、【推荐】使用 entrySet 遍历 Map 类集合 KV，而不是 keySet 方式进行遍历。
说明：keySet 其实是遍历了 2 次，一次是转为 Iterator 对象，另一次是从 hashMap 中取出
key 所对应的 value。而 entrySet 只是遍历了一次就把 key 和 value 都放到了 entry 中，效
率更高。如果是 JDK8，使用 Map.foreach 方法。
正例：values()返回的是 V 值集合，是一个 list 集合对象；keySet()返回的是 K 值集合，是
一个 Set 集合对象；entrySet()返回的是 K-V 值组合集合。
11)、【强制】主键索引名为 pk_字段名；唯一索引名为 uk_字段名；普通索引名则为 idx_字段名。
说明：pk_ 即 primary key；uk_ 即 unique key；idx_ 即 index 的简称。
12)、【强制】小数类型为 decimal，禁止使用 float 和 double。
说明：float 和 double 在存储的时候，存在精度损失的问题，很可能在值的比较时，得到不正确的结果。如果存储的数据范围超过 decimal 的范围，建议将数据拆成整数和小数分开存储。
13)、【强制】如果存储的字符串长度几乎相等，使用 char 定长字符串类型。
14)、【强制】varchar 是可变长字符串，不预先分配存储空间，长度不要超过 5000，如果存储长度大于此值，定义字段类型为 text，独立出来一张表，用主键来对应，避免影响其它字段索
引效率。
15)、【强制】表必备三字段：id, gmt_create, gmt_modified。
说明：其中 id 必为主键，类型为 bigint unsigned、单表时自增、步长为 1。gmt_create,gmt_modified 的类型均为 datetime 类型，前者现在时表示主动创建，后者过去分词表示被动更新。
16)、【推荐】单表行数超过 500 万行或者单表容量超过 2GB，才推荐进行分库分表。
说明：如果预计三年后的数据量根本达不到这个级别，请不要在创建表时就分库分表。
17)、【强制】业务上具有唯一特性的字段，即使是多个字段的组合，也必须建成唯一索引。
说明：不要以为唯一索引影响了 insert 速度，这个速度损耗可以忽略，但提高查找速度是明显的；另外，即使在应用层做了非常完善的校验控制，只要没有唯一索引，根据墨菲定律，必然有脏数据产生。
18)、【强制】超过三个表禁止 join。需要 join 的字段，数据类型必须绝对一致；多表关联查询时，保证被关联的字段需要有索引。
说明：即使双表 join 也要注意表索引、SQL 性能。
19)、【推荐】利用延迟关联或者子查询优化超多分页场景。
说明：MySQL 并不是跳过 offset 行，而是取 offset+N 行，然后返回放弃前 offset 行，返回N 行，那当 offset 特别大的时候，效率就非常的低下，要么控制返回的总页数，要么对超过特定阈值的页数进行 SQL 改写。
正例：先快速定位需要获取的 id 段，然后再关联：
SELECT
a.*
FROM
表1 a,
( SELECT id FROM 表1 WHERE 条件 LIMIT 100000, 20 ) b
WHERE
a.id = b.id
20)、【强制】不要使用 count(列名)或 count(常量)来替代 count(*)，count(*)是 SQL92 定义的标准统计行数的语法，跟数据库无关，跟 NULL 和非 NULL 无关。
说明：count(*)会统计值为 NULL 的行，而 count(列名)不会统计此列为 NULL 值的行。
21)、【强制】当某一列的值全是 NULL 时，count(col)的返回结果为 0，但 sum(col)的返回结果为NULL，因此使用 sum()时需注意 NPE 问题。
正例：可以使用如下方式来避免 sum 的 NPE 问题：
SELECT IF(ISNULL(SUM(g)),0,SUM(g))FROM table;
22)、【强制】不得使用外键与级联，一切外键概念必须在应用层解决。
说明：以学生和成绩的关系为例，学生表中的 student_id是主键，那么成绩表中的 student_id则为外键。如果更新学生表中的 student_id，同时触发成绩表中的 student_id 更新，即为级联更新。外键与级联更新适用于单机低并发，不适合分布式、高并发集群；级联更新是强阻塞，存在数据库更新风暴的风险；外键影响数据库的插入速度。
23)、【强制】禁止使用存储过程，存储过程难以调试和扩展，更没有移植性。
24)、【强制】数据订正（特别是删除、修改记录操作）时，要先 select，避免出现误删除，确认无误才能执行更新语句。
25)、【推荐】in 操作能避免则避免，若实在避免不了，需要仔细评估 in 后边的集合元素数量，控制在 1000 个之内。
26)、【强制】POJO 类的布尔属性不能加 is，而数据库字段必须加 is_，要求在 resultMap 中进行字段与属性之间的映射。
说明：参见定义 POJO 类以及数据库字段定义规定，在<resultMap>中增加映射，是必须的。在 MyBatis Generator 生成的代码中，需要进行对应的修改。
3, MySQL caracteres especiales mango:
3.1, MySQL base de datos: modificar my.cnf (Windows es my.ini)
[client]
default-character-set = utf8mb4
[mysql]
default-character-set = utf8mb4
[mysqld]
character-set-client-handshake = FALSE
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
init_connect='SET NAMES utf8mb4'
3.2, modificar la base de datos, tabla, juego de caracteres de la columna :
ALTER DATABASE database_name CHARACTER SET = utf8mb4 COLLATE = utf8mb4_unicode_ci;
ALTER TABLE table_name CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
ALTER TABLE table_name CHANGE column_name VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
3.3, modificar la conexión de base de datos de la dirección URL de :
jdbc:mysql://127.0.0.1:3306/xxx?useunicode=true&characterEncoding=utf8
A
jdbc:mysql://127.0.0.1:3306/xxx
4, configurar el POA transacción, el error de inicio del proyecto
Q:BeanPostProcessor before instantiation of bean failed
A：缺少AspectJ 注解
<!-- AspectJ 注解-->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.8</version>
</dependency>
5, el cuadro principal, y actualizar la subtabla
ps:主表、副表必须有关联字段。
UPDATE t1
JOIN t2
ON t1.t2_id = t2.id
SET t1.xxx = '',t2.yyy = ''
WHERE t1.id = 1
6, MyBatis SQL dinámico: el tipo varchar condenados vacía
<if test="xxx != null and xxx.trim() != ''">
and xxx = #{xxx}
</if>
7, para reducir al mínimo el doble recuento de las variables
Un concepto claro, las llamadas a métodos, incluso si el método es sólo una frase, hay también consume, incluyendo la creación de un marco de pila para proteger el lugar al llamar al método, el sitio de recuperación cuando los métodos de llamadas terminadas. Así, por ejemplo, las siguientes operaciones:
for (int i = 0; i < list.size(); i++){...}
alternativas recomendadas:
for (int i = 0, int length = list.size(); i < length; i++){...}
De esta manera, list.size () mucho tiempo, lo que reduce el consumo de una gran cantidad
8, precaución anormal
perjudicial para el rendimiento anormal. Una excepción es lanzada primero en crear un nuevo objeto, Throwable llamada a la función constructor de interfaz método de sincronización local llamado fillInStackTrace () es, el método fillInStackTrace () para comprobar la pila para recoger información de seguimiento de llamadas. Siempre y cuando no se produce una excepción, la máquina virtual Java debe ajustar la pila de llamadas, ya que un nuevo objeto se crea en el proceso. Una excepción sólo se puede utilizar para el tratamiento de errores, no se debe utilizar para controlar el flujo del programa.
9. No trate de usar en el bucle ... catch ..., debe ponerlo en el exterior
10, si se estima la longitud del contenido que se añade al conjunto inferior de una forma de matriz, las herramientas especifican la longitud inicial
10.1, como ArrayList, LinkedLlist, StringBuilder, StringBuffer, HashMap, HashSet, etc., con el ejemplo StringBuilder:
A), StringBuilder () // asignación de espacio por defecto es de 16 caracteres
B), StringBuilder (int size) // caracteres por defecto de tamaño de asignación de espacio
espacio C), StringBuilder (String str) // asignación por defecto es de 16 caracteres + str.length () caracteres
Puede ser establecido por la clase inicial de la capacidad (denominada en este documento como justo por encima del StringBuilder), que puede mejorar significativamente el rendimiento. Por ejemplo bar StringBuilder, de longitud indica el número de caracteres en la corriente StringBuilder pueden sostener. Debido a que el momento en que alcance la capacidad máxima StringBuilder, será en sí aumentar la capacidad actual de 2 más 2 veces, cada vez StringBuilder alcanzó su capacidad máxima, se tendrá que crear una nueva matriz de caracteres y luego el carácter antiguo copiar el contenido de la matriz a una nueva serie de caracteres - este es un rendimiento operativo muy rentable. Imagínese, si se puede estimar la matriz de caracteres para almacenar aproximadamente 5000 caracteres sin especificar la longitud de la potencia de 2 más cercano a 5000 es 4096, un momento de expansión más 2 sin tener en cuenta, a continuación:
(1), basado en el 4096, 8194 y luego aplicar un tamaño de matriz de caracteres, agregue hasta el equivalente de un presentadas 12290 caracteres tamaño de la matriz, si un inicio puede especificar el tamaño de la matriz de caracteres 5000, un ahorro de veces más espacio;
(2), los originales 4096 caracteres copiados en el nuevo carácter a la matriz.
De esta manera, una pérdida de espacio de memoria y reducir la eficiencia del código. Por lo tanto, a la matriz subyacente con el fin de lograr el conjunto de herramientas para establecer una capacidad inicial razonable que no está mal, traerá resultados inmediatos. Sin embargo, cabe destacar que esta matriz como HashMap para lograr el set list es +, usted estima el tamaño inicial y el tamaño del conjunto, al igual que, sólo por la posibilidad de un objeto de conexión en una mesa es casi cero. Recomendado para establecer el tamaño inicial N-ésima potencia de 2, si se estima que hay 2.000 elementos previstos nuevo HashMap (128), nuevo HashMap (256) puede ser utilizado.
11, operaciones de desplazamiento utilizando multiplicación y división
Por ejemplo:
for (val = 0; val < 100000; val += 5){a = val * 8;b = val / 2;}
La operación de cambio puede mejorar considerablemente el rendimiento, ya que en la parte inferior del equipo, la posición de funcionamiento es la más conveniente, más rápido, se propone modificado como sigue:
for (val = 0; val < 100000; val += 5){a = val << 3;b = val >> 1;}
operación de cambio puede ser rápido, pero puede hacer que el código entiende menos bien, lo mejor es añadir las observaciones que considere pertinentes.
12, el bucle interior no continúan para crear una referencia de objeto
Por ejemplo:
for (int i = 1; i <= count; i++){Object obj = new Object();}
Esta práctica puede conducir a la memoria tener copias recuento de objetos de referencia de objeto, contar mucho, entonces es el coste de la memoria, se recomienda leer:
Object obj = null;for (int i = 0; i <= count; i++) { obj = new Object(); }
En este caso, sólo una memoria de referencia objeto de objetos, cada nuevo objeto () cuando, objeto Objeto punto de referencia a diferentes objetos de nada, pero sólo un recuerdo, por lo tanto en gran medida ahorrar espacio de memoria para arriba.
13, para hacer uso de HashMap, ArrayList, StringBuilder, a menos que las necesidades de seguridad de rosca, o no se recomienda el uso de Hashtable, Vector, StringBuffer, los tres últimos debido a la utilización de mecanismos de sincronización que conducen a la sobrecarga de rendimiento.
14, no declarar la matriz como public static final
Debido a que este carece de sentido, sólo se define una referencia para el static final, o el contenido de la matriz se puede cambiar libremente, la matriz se declara como una vulnerabilidad de seguridad pública, lo que significa que la matriz se puede cambiar fuera de la clase.
15, en la medida de lo posible en el caso de una realización adecuada con una sola
Singleton puede reducir la carga de la carga, reducir el tiempo de carga y mejorar la eficiencia de la carga, pero no todos los lugares son adecuados para un solo caso, en términos simples, un solo caso se aplica principalmente a los tres aspectos siguientes:
15.1, controlar el uso de los recursos por la sincronización de hilos para controlar el acceso concurrente a los recursos.
15.2, la generación de la instancia de control con el fin de ahorrar recursos.
15.3, el intercambio de datos de control, en condiciones que no están directamente relacionados con el establecimiento, de manera que la comunicación entre múltiples procesos no relacionados o hilos.
16, tratar de evitar el uso de variable aleatoria estática
Ya sabes, cuando la referencia a un objeto se define como una variable estática, entonces GC, normalmente, ni reclamar la memoria heap ocupada por objetos, tales como:
public class A{private static B b = new B();}
En este variable estática b del ciclo de vida de la misma clase A, clase A si no desinstalado, entonces la referencia de objeto B punto B será la memoria permanente, hasta que se termina el programa.
17, iterativo entrySet () Devuelve la asignación de la clave y el valor
Cuando el ciclo sólo tiene que conseguir Mapa clave principal clave, iteración conjunto de claves () es correcta, sin embargo, cuando se necesita un valor de clave principal y el valor clave, la iteración entrySet () es un método más eficiente que el conjunto de claves de su primera iteración ( ) y luego ir a través de conseguir una mejor relación rendimiento.
contraejemplo:
//Map 获取value 反例:
HashMap<String, String> map = new HashMap<>();
for (String key : map.keySet()){
String value = map.get(key);
}
Ejemplos positivos:
//Map 获取key & value 正例:
HashMap<String, String> map = new HashMap<>();
for (Map.Entry<String,String> entry : map.entrySet()){
String key = entry.getKey();
String value = entry.getValue();
}
18. Para recuperar método Collection.contains use con frecuencia el Conjunto
En la biblioteca de clases de Java colección, lista contiene el método general de la complejidad en tiempo de O (n), si el código contiene llamadas a métodos con frecuencia se encuentran el primer conjunto de datos se convierte en una lista HashSet logra, el O (n) tiempo de complejidad grado será O (1).
contraejemplo:
//频繁调用Collection.contains() 反例
List<Object> list = new ArrayList<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
//时间复杂度为O(n)
if (list.contains(i))
System.out.println("list contains "+ i);
}
Ejemplos positivos:
//频繁调用Collection.contains() 正例
List<Object> list = new ArrayList<>();
Set<Object> set = new HashSet<>();
for (int i = 0; i <= Integer.MAX_VALUE; i++){
//时间复杂度为O(1)
if (set.contains(i)){
System.out.println("list contains "+ i);
}
}
19, herramientas escudo constructor
Tools es una colección de un montón de campos estáticos y funciones, que no debe ser una instancia, sin embargo, Java añade un constructor público implícito para cada clase no se define explícitamente el constructor, con el fin de evitar la creación de instancias innecesaria, se debe definir explícitamente para proteger a los constructores privados constructor público implícito.
contraejemplo:
public class PasswordUtils {
//工具类构造函数反例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);
public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";
public static String encryptPassword(String aPassword) throws IOException {
return new PasswordUtils(aPassword).encrypt();
}
}
Ejemplos positivos:
public class PasswordUtils {
//工具类构造函数正例
private static final Logger LOG = LoggerFactory.getLogger(PasswordUtils.class);
//定义私有构造函数来屏蔽这个隐式公有构造函数
private PasswordUtils(){}
public static final String DEFAULT_CRYPT_ALGO = "PBEWithMD5AndDES";
public static String encryptPassword(String aPassword) throws IOException {
return new PasswordUtils(aPassword).encrypt();
}
}
20, MySQL_int (10) ¿Qué significa?
MySQL int (10) en los medios 10 es: en esta salida de campo pueden La longitud máxima de una pantalla digital. número Anchura de paréntesis, se llama datos, los diferentes tipos de datos no son la misma anchura de procesamiento:
20.1, tipos de enteros : tipo y anchura de la gama aquí datos es ninguna relación, pero la anchura de la pantalla indica el máximo número posible de dígitos mostrados Mysql, poblada por un espacio menor que el valor especificado cuando el número de bits de anchura;
Si el valor es mayor que la pantalla de ancho se inserta, siempre que el valor no exceda el rango del tipo, los valores pueden todavía ser insertados, y se pueden mostrar.
Si no se establece una anchura, el sistema añadirá el tinyint ancho predeterminado (4), smallint (6), MEDIUMINT (9), int (11), bigint (20), que es el ancho predeterminado de la gama del tipo con una longitud relacionados.
20.2, tipo de cadena : tipo de cadena esta anchura se utiliza realmente. Ya sea CHAR o VARCHAR, ancho define la longitud máxima de la cadena, por ejemplo, la contraseña anterior varchar (20), si se introduce una contraseña de 21 caracteres, a continuación, guardar y mostrar sólo los primeros 20 caracteres, una información de caracteres se perderá, empatía carbón. Desde varchar es un dispositivo de almacenamiento de longitud variable, por lo que generalmente consideramos que el desarrollo real de la anchura varchar de hasta 255, se basa en el cambio de longitud de datos real, de todos modos, que no se quede fuera de él no será un desperdicio de espacio. char es un almacenamiento de longitud fija, definir cuánto tiempo es largo.
20.3, tipos de datos en coma flotante, y la fecha de : datos de anchura no se requiere, por lo general no se proporciona, el valor predeterminado es 0.
