java开发之提高java和mysql代码性能和质量
2014-04-21 10:44
501 查看
0.if嵌套的层数最好不要超过3层
点击(此处)折叠或打开
import java.util.HashMap;
import java.util.Map;
public class Qiantao {
/*
* 嵌套太多层if,阅读性非常差,和看递归代码一样
* @author yifangyou
* @since 2011-08-16 09:35:00
*/
int example1(int a,String path,String account,String user){
int result=0;
if(account!=null){
if(a==1){
if("/createAccount".equals(path)){
if(createAccount(account)){
result=1;
}else{
return -4;
}
}else if("/createUser".equals(path)){
if(i***istsAccount(account)){
if(createUser(account,user)){
result=2;
}else{
return -6;
}
}else{
return -5;
}
}else{
result=-3;
}
}else{
result=-2;
}
}else{
result=-1;
}
return result;
}
Map<String,Integer> paths=new HashMap<String,Integer>(){{
this.put("/createAccount", 1);
this.put("/createUser", 2);
}};
/*
* 采用return减少嵌套层数,层次分明,便于修改,增加和删除判断比较容易
* @author yifangyou
* @since 2011-08-16 09:35:00
*/
int example2(int a,String path,String account,String user){
if(account==null){
return -1;
}
if(a!=1){
return -2;
}
Integer pathId=paths.get(path);
if(pathId==null){
return -3;
}
switch(pathId){
case 1:
if(!createAccount(account)){
return -4;
}
return 1;
case 2:
if(!i***istsAccount(account)){
return -5;
}
if(!createUser(account,user)){
return -6;
}
return 2;
default:
return 0;
}
}
private boolean i***istsAccount(String account) {
// TODO Auto-generated method stub
return false;
}
private boolean createUser(String account, String user) {
// TODO Auto-generated method stub
return false;
}
private boolean createAccount(String account) {
// TODO Auto-generated method stub
return false;
}
}
1.尽量重用数据库连接或者文件句柄
2.过分的创建对象会消耗系统的大量内存,严重时,会导致内存泄漏,因此,保证过期的对象的及时回收具有重要意义。
JVM的GC并非十分智能,因此建议在对象使用完毕后,手动设置成null。
3.采用在需要的时候才开始创建的策略。
4.array(数组)和ArrayList的使用。
array 数组效率最高,但容量固定,无法动态改变,ArrayList容量可以动态增长,但牺牲了效率。
5.尽量使用基本数据类型代替对象。
6.使用具体类比使用接口效率高,但结构弹性降低了
7.读取配置文件内容,最好放在static变量里,不要用到时再解析配置文件
8.避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量
9.输入和输出(I/O),避免多次读写同一个文件,读时最好尽量一次读取完需要的数据,写时,先把要写的内容全部放到变量里,一次写入文件
10.数据库查询最好使用PrepStatement防止SQL注入,提高性能,prepStatement减少解析sql语句时间
点击(此处)折叠或打开
drop table IF EXISTS t1;
create table t1(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));
drop table IF EXISTS t2;
create table t2(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));
DROP PROCEDURE IF EXISTS test;
DELIMITER ;;
CREATE PROCEDURE test()
BEGIN
truncate t1;
truncate t2;
set @start_time=UNIX_TIMESTAMP();
set @id=1;
SET @sql_str = "insert into t1 values(?,'a')";
PREPARE stmt FROM @sql_str;
REPEAT
EXECUTE stmt USING @id;
set @id=@id+1;
UNTIL @id>100000 END REPEAT;
DEALLOCATE PREPARE stmt;
select UNIX_TIMESTAMP()-@start_time as span;
set @start_time=UNIX_TIMESTAMP();
set @id=1;
REPEAT
insert into t2 values(@id,'a');
set @id=@id+1;
UNTIL @id>100000 END REPEAT;
select UNIX_TIMESTAMP()-@start_time as span;
END;;
DELIMITER ;
call test();
11.能够在数据库里做的操作,尽量在数据库里做,因为数据是集合运算
12.带索引的inner join 比in效率高得多
点击(此处)折叠或打开
select count(*) from region;
select count(*) from cidr;
select SQL_NO_CACHE count(*) from cidr where region_id in(select id from region);
select SQL_NO_CACHE count(*) from cidr inner join region on cidr.region_id=region.id;
13.经常查询的字段加上索引,这个能够提高20倍
14. 当只要一行数据时使用 LIMIT 1,这样mysql查询到1条后可以马上返回结果;
15.避免 SELECT *,查询哪个字段就写哪个,这样可以减少查询时间和网络传输;
16. 拆分大的 DELETE 或 INSERT 语句
如果你需要在一个在线的网站上去执行一个大的 DELETE 或 INSERT 查询,你需要非常小心,要避免你的操作让你的整个网站停止相应。
因为这两个操作是会锁表的,表一锁住了,别的操作都进不来了。
17.隐式提交
在事务执行过程中,执行下面语句相当于执行COMMIT
点击(此处)折叠或打开
ALTER FUNCTION, ALTER PROCEDURE, ALTER TABLE, BEGIN, CREATE DATABASE, CREATE FUNCTION, CREATE INDEX, CREATE PROCEDURE, CREATE TABLE, DROP DATABASE, DROP FUNCTION, DROP INDEX, DROP PROCEDURE, DROP TABLE, LOAD MASTER DATA, LOCK TABLES, RENAME TABLE, SET AUTOCOMMIT=1, START TRANSACTION, TRUNCATE TABLE, UNLOCK TABLES.
runcate 或者drop临时表会引起隐式提交
CREATE TEMPORARY TABLE 临时表不会引起隐式提交
delete from 临时表不会引起隐式提交
CREATE VIEW 会引起隐式提交
18.事务并行问题,按照谁先执行事务的顺序生效
两个事务同时delete,update,insert操作同一行时,或者含有自增id时会引起挂起
点击(此处)折叠或打开
create table t(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));
create table t(id int NOT NULL,name varchar(10));
--客户端A
SET AUTOCOMMIT =0;
insert into t values (1,'a');
--客户端 B
SET AUTOCOMMIT =0;
insert into t values (1,'b');
----------------------------------------
--客户端A
SET AUTOCOMMIT =0;
insert into t values (2,'a');
--客户端 B
SET AUTOCOMMIT =0;
delete from t where id=2;
--或者
update t set name='c' where id=2;
----------------------------------------
--客户端A
SET AUTOCOMMIT =0;
delete from t where id=2;
--客户端 B
SET AUTOCOMMIT =0;
update t set name='c' where id=2;
--或者
delete from t where id=2;
点击(此处)折叠或打开
import java.util.HashMap;
import java.util.Map;
public class Qiantao {
/*
* 嵌套太多层if,阅读性非常差,和看递归代码一样
* @author yifangyou
* @since 2011-08-16 09:35:00
*/
int example1(int a,String path,String account,String user){
int result=0;
if(account!=null){
if(a==1){
if("/createAccount".equals(path)){
if(createAccount(account)){
result=1;
}else{
return -4;
}
}else if("/createUser".equals(path)){
if(i***istsAccount(account)){
if(createUser(account,user)){
result=2;
}else{
return -6;
}
}else{
return -5;
}
}else{
result=-3;
}
}else{
result=-2;
}
}else{
result=-1;
}
return result;
}
Map<String,Integer> paths=new HashMap<String,Integer>(){{
this.put("/createAccount", 1);
this.put("/createUser", 2);
}};
/*
* 采用return减少嵌套层数,层次分明,便于修改,增加和删除判断比较容易
* @author yifangyou
* @since 2011-08-16 09:35:00
*/
int example2(int a,String path,String account,String user){
if(account==null){
return -1;
}
if(a!=1){
return -2;
}
Integer pathId=paths.get(path);
if(pathId==null){
return -3;
}
switch(pathId){
case 1:
if(!createAccount(account)){
return -4;
}
return 1;
case 2:
if(!i***istsAccount(account)){
return -5;
}
if(!createUser(account,user)){
return -6;
}
return 2;
default:
return 0;
}
}
private boolean i***istsAccount(String account) {
// TODO Auto-generated method stub
return false;
}
private boolean createUser(String account, String user) {
// TODO Auto-generated method stub
return false;
}
private boolean createAccount(String account) {
// TODO Auto-generated method stub
return false;
}
}
1.尽量重用数据库连接或者文件句柄
2.过分的创建对象会消耗系统的大量内存,严重时,会导致内存泄漏,因此,保证过期的对象的及时回收具有重要意义。
JVM的GC并非十分智能,因此建议在对象使用完毕后,手动设置成null。
3.采用在需要的时候才开始创建的策略。
4.array(数组)和ArrayList的使用。
array 数组效率最高,但容量固定,无法动态改变,ArrayList容量可以动态增长,但牺牲了效率。
5.尽量使用基本数据类型代替对象。
6.使用具体类比使用接口效率高,但结构弹性降低了
7.读取配置文件内容,最好放在static变量里,不要用到时再解析配置文件
8.避免在同一个类中动过调用函数或方法(get或set)来设置或调用变量
9.输入和输出(I/O),避免多次读写同一个文件,读时最好尽量一次读取完需要的数据,写时,先把要写的内容全部放到变量里,一次写入文件
10.数据库查询最好使用PrepStatement防止SQL注入,提高性能,prepStatement减少解析sql语句时间
点击(此处)折叠或打开
drop table IF EXISTS t1;
create table t1(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));
drop table IF EXISTS t2;
create table t2(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));
DROP PROCEDURE IF EXISTS test;
DELIMITER ;;
CREATE PROCEDURE test()
BEGIN
truncate t1;
truncate t2;
set @start_time=UNIX_TIMESTAMP();
set @id=1;
SET @sql_str = "insert into t1 values(?,'a')";
PREPARE stmt FROM @sql_str;
REPEAT
EXECUTE stmt USING @id;
set @id=@id+1;
UNTIL @id>100000 END REPEAT;
DEALLOCATE PREPARE stmt;
select UNIX_TIMESTAMP()-@start_time as span;
set @start_time=UNIX_TIMESTAMP();
set @id=1;
REPEAT
insert into t2 values(@id,'a');
set @id=@id+1;
UNTIL @id>100000 END REPEAT;
select UNIX_TIMESTAMP()-@start_time as span;
END;;
DELIMITER ;
call test();
11.能够在数据库里做的操作,尽量在数据库里做,因为数据是集合运算
12.带索引的inner join 比in效率高得多
点击(此处)折叠或打开
select count(*) from region;
select count(*) from cidr;
select SQL_NO_CACHE count(*) from cidr where region_id in(select id from region);
select SQL_NO_CACHE count(*) from cidr inner join region on cidr.region_id=region.id;
13.经常查询的字段加上索引,这个能够提高20倍
14. 当只要一行数据时使用 LIMIT 1,这样mysql查询到1条后可以马上返回结果;
15.避免 SELECT *,查询哪个字段就写哪个,这样可以减少查询时间和网络传输;
16. 拆分大的 DELETE 或 INSERT 语句
如果你需要在一个在线的网站上去执行一个大的 DELETE 或 INSERT 查询,你需要非常小心,要避免你的操作让你的整个网站停止相应。
因为这两个操作是会锁表的,表一锁住了,别的操作都进不来了。
17.隐式提交
在事务执行过程中,执行下面语句相当于执行COMMIT
点击(此处)折叠或打开
ALTER FUNCTION, ALTER PROCEDURE, ALTER TABLE, BEGIN, CREATE DATABASE, CREATE FUNCTION, CREATE INDEX, CREATE PROCEDURE, CREATE TABLE, DROP DATABASE, DROP FUNCTION, DROP INDEX, DROP PROCEDURE, DROP TABLE, LOAD MASTER DATA, LOCK TABLES, RENAME TABLE, SET AUTOCOMMIT=1, START TRANSACTION, TRUNCATE TABLE, UNLOCK TABLES.
runcate 或者drop临时表会引起隐式提交
CREATE TEMPORARY TABLE 临时表不会引起隐式提交
delete from 临时表不会引起隐式提交
CREATE VIEW 会引起隐式提交
18.事务并行问题,按照谁先执行事务的顺序生效
两个事务同时delete,update,insert操作同一行时,或者含有自增id时会引起挂起
点击(此处)折叠或打开
create table t(id int NOT NULL AUTO_INCREMENT,name varchar(10),PRIMARY KEY (`id`));
create table t(id int NOT NULL,name varchar(10));
--客户端A
SET AUTOCOMMIT =0;
insert into t values (1,'a');
--客户端 B
SET AUTOCOMMIT =0;
insert into t values (1,'b');
----------------------------------------
--客户端A
SET AUTOCOMMIT =0;
insert into t values (2,'a');
--客户端 B
SET AUTOCOMMIT =0;
delete from t where id=2;
--或者
update t set name='c' where id=2;
----------------------------------------
--客户端A
SET AUTOCOMMIT =0;
delete from t where id=2;
--客户端 B
SET AUTOCOMMIT =0;
update t set name='c' where id=2;
--或者
delete from t where id=2;
相关文章推荐
- java开发之提高java和mysql代码性能和质量
- 提高java和mysql代码性能和质量
- 提高Java开发质量之性能瓶颈
- 提高你的Java代码质量吧:多使用异常,把性能问题放一边
- 字节码防止内存错误及提高代码质量-Java基础-Java-编程开发
- 提高你的Java代码质量吧:性能考虑,数组是首选
- java 让开发自动化: 用 Eclipse 插件提高代码质量
- 提高你的Java代码质量吧:多使用异常,把性能问题放一边
- 完整java开发中JDBC连接mysql或者其他数据库代码和步骤
- 让开发自动化: 用 Eclipse 插件提高代码质量
- 让开发自动化: 用 Eclipse 插件提高代码质量
- 提高你的Java代码质量吧:字符拼接位置的玄机
- 提高你的Java代码质量吧:在switch的default代码块中增加AssertionError错误
- Java开发代码性能优化总结
- 让开发自动化: 用 Eclipse 插件提高代码质量
- Javascript模块化开发,使用模块化脚本加载工具RequireJS,提高你代码的速度和质量。
- 提高你的Java代码质量吧:不容忽视的四舍五入细节
- 使用临时变量提高Java代码性能 (转)
- java代码性能的提高
- 如何优化JAVA程序开发,提高JAVA性能?