[关闭]
@big-bear 2017-12-15T03:32:44.000000Z 字数 14068 阅读 1056

Java 编程细节

Java 我的征途是全栈

java

1. map遍历

  1. for (Map.Entry<String, Object> entry : param.entrySet()) {
  2.             Boolean buildSuccess = ElasticSearchUtil.addJsonProperty(json, entry);
  3.             if (!buildSuccess) {
  4.                 LOGGER.error("不支持" + entry.getKey() + "字段的相关类型:" + entry.getValue().getClass().toString());
  5.                 return false;
  6.             }
  7.         }

java时间操作

  1. Date date=new Date();
  2. DateFormat format=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//24小时
  3. DateFormat format=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//12小时
  4. //date to string
  5. String time=format.format(date);
  6. //string to date
  7. Date date = format.parse(szBeginTime);
  8. //两个时间比较大小
  9. Calendar c1 = Calendar.getInstance();
  10. Calendar c2 = Calendar.getInstance();
  11. c1.setTime(comDate);
  12. c2.setTime(creDate);
  13. System.out.println(c2.get(Calendar.DAY_OF_MONTH) - c1.get(Calendar.DAY_OF_MONTH));
  14. //date比较大小
  15. date1.compareTo(date2) //返回值0,1,-1:date1>date2返回1
  17. //获取Date类型中的年份;(DateTime为JodaTime)
  18. String graduateYear = new Integer(new DateTime(date).getYear()).toString();

quartz表达式范例

Cron表达式范例：
每隔5秒执行一次：*/5 * * * * ?
每隔1分钟执行一次：0 */1 * * * ?
每天23点执行一次：0 0 23 * * ?
每天凌晨1点执行一次：0 0 1 * * ?
每月1号凌晨1点执行一次：0 0 1 1 * ?
每月最后一天23点执行一次：0 0 23 L * ?
每周星期天凌晨1点实行一次：0 0 1 ? * L
在26分、29分、33分执行一次：0 26,29,33 * * * ?
每天的0点、13点、18点、21点都执行一次：0 0 0,13,18,21 * * ?

quartz Spring配置

  1. <!--配置quartz定时任务  -->
  2.      <!-- ①配置调度的任务对应bean的id和自定义class-->
  3.     <bean id="leaderListener" class="com.srtc.quartz.LeaderListener">
  4.         <property name="userSrv" ref="sec_userSrv" />
  5.     </bean>
  6.      <!-- ②配置调度任务对应的bean的id和执行的方法,作业不并发调度-->
  7.     <bean id="myTask" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
  8.          <property name="targetObject" ref="leaderListener" />
  9.          <property name="targetMethod" value="linstenLeader" />
  10.     </bean>
  11.     <bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
  12.         <property name="jobDetail" ref="myTask" />
  13.          <property name="cronExpression">
  14.          <!-- 每十分钟执行任务调度 -->
  15.           <value>* */10 * * * ?</value>
  16.         </property>
  17.   </bean>
  18.       <!--  ④Quartz的调度工厂，调度工厂只能有一个，多个调度任务在list中添加 -->
  19.   <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
  20.     <property name="triggers">
  21.       <list>
  22.          <!-- 所有的调度列表-->
  23.         <ref bean="myTrigger" />
  24. <!-- <ref bean="myTrigger1" />
  25.         <ref bean="myTrigger2" />
  26.         对应的bean配置：id="myDetail1" 和 id="myTrigger1" 可以对应多配置
  27.   -->
  28.       </list>
  29.     </property>
  30.   </bean>

quartz 单线程执行

防止job并行运行的几种解决方案:
一、JOB State 在通过MethodInvokingJobDetailFactoryBean在运行中动态生成的Job，配置的xml文件有个concurrent属性，表示job是否可以并行运行：如果一个job的业务处理发费的时间超过了job的启动的间隔时间（repeatInterval)，这个属性非常有用。如果为false，那么，在这种情况下，当前job还在运行，那么下一个job只能延时运行。如果为true，那么job就会并行运行。在实际的应用中应该配置为true/false，要根据需要了（废话）。
二、如果通过继承QuartzJobBean实现job的话，默认情况下QuartzJobBean是implements org.quartz.Job接口的，也就是说job示例是stateless的，会出现前面所述的并行情况。而代码中却要求job任务必需串行，解决办法：在job子类中继续implements org.quartz.StatefulJob。那么这个job实例变成了Stateful，job任务也就是串行的了。 注： 在Quartz中，如果实现org.quartz.Job接口，那么这个job是stateless的，job实例的参数不能在多个任务之间共享，如果实现org.quartz.StatefulJob，这个job是个单例的，job实例的属性可以从当前任务传递到下一个任务。

切分字符串生成数组

  1. String studentIdStrs[] = this.ids.split(",");

java array to list

  1. 　　String[] arr = new String[] {"1", "2"};
  2. 　　List list = Arrays.asList(arr);

java list to array

  1. List list = new ArrayList();
  2. list.add("1");
  3. list.add("2");
  4. final int size =　list.size();
  5. String[] arr = (String[])list.toArray(new String[size]);

截取目标数组生成一个新的数组

  1. Object[] dataObjects = new Object[objects.length - 1];
  2. System.arraycopy(objects, 1, dataObjects, 0, dataObjects.length);

system.arraycopy()方法的解释
其函数原型是： public static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length) src:源数组； srcPos:源数组要复制的起始位置； dest:目的数组； destPos:目的数组放置的起始位置； length:复制的长度

Gson将对象转换为json字符串

  1. AAAA a = new AAAA();
  2. string aaa = new Gson().toJson(a);

小数点位数问题

http://blog.csdn.net/tianlincao/article/details/5654880

URL中文传参乱码问题

  1.   String factoryName = new String(request.getParameter("factoryName").getBytes("ISO-8859-1"), "utf-8");

这个问题也可以通过修改tomcat的默认传参编码来解决

  1. <Connector port="8000" protocol="HTTP/1.1" URIEncoding="UTF-8"
  2.            connectionTimeout="20000"
  3.            redirectPort="8443" />

tomcat的默认编码是ISO-8859-1 ,所以产生了中文乱码问题

判断是否是ajax请求

  1.     /**
  2.      * 判断是否是ajax请求. <br/>
  3.      * 
  4.      * @author ghlin
  5.      * @return
  6.      */
  7.     public boolean isAjaxRequest() {
  8.         String header = request.getHeader("X-Requested-With");
  9.         if (header != null && "XMLHttpRequest".equalsIgnoreCase(header))
  10.             return true;
  11.         else
  12.             return false;
  13.     }

获取一个类的所有属性名称

  1. private String[] getFiledName(Object o) {
  2.         Field[] fields = o.getClass().getDeclaredFields();
  3.         String[] fieldNames = new String[fields.length];
  4.         for (int i = 0; i < fields.length; i++) {
  5.             System.out.println(fields[i].getType());
  6.             fieldNames[i] = fields[i].getName();
  7.         }
  8.         return fieldNames;
  9.     }

自定义注解

定义注解

  1. package com.wisdombud.alumnimanage.web.annotation;
  3. import java.lang.annotation.ElementType;
  4. import java.lang.annotation.Retention;
  5. import java.lang.annotation.RetentionPolicy;
  6. import java.lang.annotation.Target;
  8. /**
  9.  * 功能: 比较属性值注解.<br/>
  10.  * date: 2016年9月14日 下午5:37:35 <br/>
  11.  *
  12.  * @author zlliu
  13.  * @version
  14.  * @since JDK 1.7
  15.  */
  16. @Retention(RetentionPolicy.RUNTIME)
  17. @Target({ ElementType.FIELD, ElementType.METHOD })
  18. public @interface ContrastValue {
  19.     /**
  20.      * 功能: 属性中文名称.<br/>
  21.      * date: 2016年9月14日 下午5:42:51 <br/>
  22.      *
  23.      * @author zlliu
  24.      * @return
  25.      */
  26.     String zhName();
  27. }

获取注解值

  1.     Field[] fields = newPojo.getClass().getDeclaredFields();//newPojo为字段加了注解的类的实例化对象
  2.     try {
  3.             for (int j = 0; j < fields.length; j++) {
  4.                 ContrastValue meta = fields[j].getAnnotation(ContrastValue.class);
  5.                 Method getMethod = newPojo.getClass().getMethod("get" + name);
  6.             }
  7.         }

java向下转型

在向下转型过程中，分为两种情况：

情况一：如果父类引用的对象如果引用的是指向的子类对象，那么在向下转型的过程中是安全的。也就是编译是不会出错误的。

情况二：如果父类引用的对象是父类本身，那么在向下转型的过程中是不安全的，编译不会出错，但是运行时会出现java.lang.ClassCastException错误。它可以使用instanceof来避免出错此类错误

  2. public class Girl {
  4.          public void smile(){
  6.                    System.out.println("girl smile()...");
  8.          }
  10. }
  12. class MMGirl extends Girl{
  13.                    @Override
  14.      public void smile() {
  15.         System.out.println("MMirl smile sounds sweet...");
  16.          }
  17.          public void c(){
  18.             System.out.println("MMirl c()...");
  19.          }
  20. }
  22. class main{
  24.                    public static void main(String[] args) {
  26.                    Girl g1=new MMGirl(); //向上转型
  28.                    g1.smile();
  30.                    MMGirl mmg=(MMGirl)g1;    //向下转型,编译和运行皆不会出错
  32.                    mmg.smile();
  34.                    mmg.c();
  36.                    Girl g2=new Girl();
  38.            //MMGirl mmg1=(MMGirl)g2; //不安全的向下转型,编译无错但会运行会出错
  40.            //mmg1.smile();
  42.            //mmg1.c();
  44.                    if(g2 instanceof MMGirl){
  46.                             MMGirl mmg1=(MMGirl)g2;
  48.                             mmg1.smile();
  50.                             mmg1.c();
  52.                    }
  54.          }

java获取泛型T的class

  1. import java.lang.reflect.ParameterizedType;
  2. import java.lang.reflect.Type;
  4. public class BaseCrudServiceImpl<T extends BaseDataEntity> extends AbstractService<T> implements BaseCrudService<T> {
  6.     @PersistenceContext
  7.     private EntityManager em;
  9.     private Class<T> entityClass;
  11.     public BaseCrudServiceImpl() {//在构造方法时初始化entity
  12.         Type genType = getClass().getGenericSuperclass();
  13.         Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
  14.         entityClass = (Class) params[0];
  15.     }

关于初始化时候的异常解决方案子类继承的时候需要传给父类一个确切的类型,而依旧传递一个T

java的参数传递

Java 应用程序中的变量可以为以下两种类型之一：引用类型或基本类型。当作为参数传递给一个方法时，处理这两种类型的方式是相同的。两种类型都是按值传递的；没有一种按引用传递。
按值传递和按引用传递。按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。因此，如果函数修改了该参数，调用代码中的原始值也随之改变。

字符串首字母大写

  1.  public static String captureName(String name) {
  2.    //     name = name.substring(0, 1).toUpperCase() + name.substring(1);
  3. //        return  name;
  4.         char[] cs=name.toCharArray();
  5.         cs[0]-=32;
  6.         return String.valueOf(cs);
  8.     }

当然还有~

  1. StringUtils.capitalize(kathValue.getType())//Apache的包~

线程池simple demo

  1. ExecutorService pool = Executors.newFixedThreadPool(tenants.size());
  2.         for (Tenant tenant : tenants) {
  3.             pool.submit(new Runnable() {
  4.                 @Override
  5.                 public void run() {
  6.                     // sysTenantData(tenant);
  7.                     System.out.println("我要好好学习");
  8.                 }
  9.             });
  10.         }
  11.         pool.shutdown();

类的初始化顺序

父类静态变量——父类静态代码块——子类静态代码块——父类非静态变量——父类非静态代码块——父类构造函数——子类非静态变量——子类非静态代码块——子类构造函数

java反射

instanceof, isinstance,isAssignableFrom的区别

instanceof运算符

只被用于对象引用变量，检查左边的被测试对象 是不是 右边类或接口的 实例化。如果被测对象是null值，则测试结果总是false。
形象地：自身实例或子类实例 instanceof 自身类 返回true 

  1. String s=new String("javaisland"); 
  2. System.out.println(s instanceof String); //true

Class类的isInstance(Object obj)方法

obj是被测试的对象，如果obj是调用这个方法的class或接口 的实例，则返回true。这个方法是instanceof运算符的动态等价。
形象地：自身类.class.isInstance(自身实例或子类实例) 返回true 

  1. String s=new String("javaisland"); 
  2. System.out.println(String.class.isInstance(s)); //true

Class类的isAssignableFrom(Class cls)方法

如果调用这个方法的class或接口 与 参数cls表示的类或接口相同，或者是参数cls表示的类或接口的父类，则返回true。
形象地：自身类.class.isAssignableFrom(自身类或子类.class) 返回true 

  1. System.out.println(ArrayList.class.isAssignableFrom(Object.class));  //false 
  2.       System.out.println(Object.class.isAssignableFrom(ArrayList.class));  //true

hibernate

hibernate id自增策略

  1. @Id
  2. @GeneratedValue(strategy=GenerationType.IDENTITY)
  3. private long id;

hibernate应用多对多是,联查语句

  1. select job From BaseJob job inner join job.domains as domain where domain.id != null

hibernate忽略dao层的写法

po的写法,

  1. package com.wisdombud.career.pojo;
  3. import java.io.Serializable;
  5. import javax.persistence.Entity;
  6. import javax.persistence.NamedQueries;
  7. import javax.persistence.NamedQuery;
  8. import javax.persistence.Table;
  10. @Entity
  11. @Table(name = "dic_enum")
  12. @NamedQueries({ @NamedQuery(name = "DicEnum.findAll", query = "SELECT d FROM DicEnum d") })//主要区别在这里
  13. public class DicEnum implements Serializable {
  14.     public DicEnum() {
  16.     }
  18.     private String code;
  20.     private String value;
  22.     public String getCode() {
  23.         return code;
  24.     }
  26.     public void setCode(String code) {
  27.         this.code = code;
  28.     }
  30.     public String getValue() {
  31.         return value;
  32.     }
  34.     public void setValue(String value) {
  35.         this.value = value;
  36.     }
  38. }

调用方法如下

  1. public List<DicEnum> findAllDicEnums() {
  2.         final Query query = super.getSession().getNamedQuery("DicEnum.findAll");
  3.         return query.list();
  4.     }

hibernate sql手动配置映射

  1.     public void page(PageEntity<BaseJob> entitys, Map<String, Object> parms) {
  3.         StringBuilder sql = new StringBuilder();
  4.         sql.append("SELECT b.name, b.id,b.job,i.cn_name as cnName,b.work_area as workArea,b.end_time as endTime");
  5.         sql.append(" FROM base_jobs b LEFT JOIN base_io i ON (b.base_io_id = i.id)");
  6.         sql.append(" WHERE 1 = 1");
  7.         buildParm(sql, parms);
  8.         sql.append(" order by b.create_time desc");
  9.         pageBySql(sql.toString(), entitys, new QueryExtension<BaseJob>() {
  10.             @Override
  11.             public void doExtend(final SQLQuery sq) {
  12.                 sq.addEntity("name");
  13.                 sq.addScalar("id");
  14.                 sq.addScalar("job");
  15.                 sq.addScalar("cnName");
  16.                 sq.addScalar("workArea");
  17.                 sq.addScalar("endTime");
  18.                 sq.setResultTransformer(Transformers.aliasToBean(BaseJob.class));
  19.             }
  20.         }, parms);
  21.     }

hibernate配置关联时Gson序列化无限循环解决

  1.     @GsonNotSerialize
  2.     private List<SecRolePojo> rolePojos;

不入库注解

  1.     @Transient
  2.     private Integer memberNum;

hibernate cascade(级联)

级联（Cascade） ： 二个以上的设备通过某种方式连接起来，能起到扩容的效果就是级联。Hibernate级联（Cascade）是用来说明数据库中两个表之间相互关系(一对一,一对多,多对多)中，当对主对象进行某种操作时，是否对其关联的从对象也作类似的操作（比如有对象Department和Employee，它们之间是一对多的关系，当保存Department时，其对应的Employee是否也相应的保存），常见的级联(Cascade)有：
(1)none：在保存，删除或修改当前对象时，不对其附属对象（关联对象）进行级联操作。它是默认值。
(2)save-update：在保存，更新当前对象时，级联保存，更新附属对象(临时对象，游离对象)。
(3)delete：在删除当前对象时，级联删除附属对象。
(4)all：所有情况下均进行级联操作，即包含save-update和delete等等操作。
(5)delete-orphan：删除此对象的同时删除与当前对象解除关系的孤儿对象(仅仅使用于一对多关联关系中)。

hibernate 多对多(双向)

  1. pojo1
  1.    @ManyToMany(cascade=CascadeType.ALL)  
  2.     @JoinTable(name="alumni_assoc_member", 
  3.     joinColumns=@JoinColumn(name="ASSOC_ID"),
  4.     inverseJoinColumns=@JoinColumn(name="ALUMNI_ID")) 
  5.     private Set<AlumniInfoPojo> alumnis;
  1. pojo2
  1.     @ManyToMany(cascade=CascadeType.ALL, mappedBy="alumnis")  
  2.     private Set<BranchPojo> branchs;

hiberante @column属性解释

insertable

insertable属性表示在使用“INSERT”脚本插入数据时，是否需要插入该字段的值。

updatable

updatable属性表示在使用“UPDATE”脚本插入数据时，是否需要更新该字段的值。insertable和updatable属性一般多用于只读的属性，例如主键和外键等。这些字段的值通常是自动生成的。

name

name属性定义了被标注字段在数据库表中所对应字段的名称；

unique

unique属性表示该字段是否为唯一标识，默认为false。如果表中有一个字段需要唯一标识，则既可以使用该标记，也可以使用@Table标记中的@UniqueConstraint。

nullable

nullable属性表示该字段是否可以为null值，默认为true。

columnDefinition

columnDefinition属性表示创建表时，该字段创建的SQL语句，一般用于通过Entity生成表定义时使用。（也就是说，如果DB中表已经建好，该属性没有必要使用。）

table

table属性定义了包含当前字段的表名。

length

length属性表示字段的长度，当字段的类型为varchar时，该属性才有效，默认为255个字符。

precision和scale

precision属性和scale属性表示精度，当字段类型为double时，precision表示数值的总长度，scale表示小数点所占的位数。

@notFound

@NotFound(action = NotFoundAction.IGNORE)
使用hibernate 注解配置实体类的关联关系，在many-to-one,one-to-one关联中，一边引用自另一边的属性，如果属性值为某某的数据在数据库不存在了，hibernate默认会抛出异常。解决此问题，加上如下注解就可以了：
@NotFound(action=NotFoundAction.IGNORE)，意思是找不到引用的外键数据时忽略，NotFound默认是exception
原文博客

  2.     @ManyToOne
  3.     @JoinColumn(name = "parentid", nullable = true, foreignKey = @ForeignKey(name = "null"))
  4.     @NotFound(action = NotFoundAction.IGNORE)
  5.     public Department getParent() {
  6.         return parent;
  7.     }

JSP

S标签判空

  1.   <s:if test="transferringStudentInfoVo.attachment!=null&&!''.equals(transferringStudentInfoVo.attachment)">
  2. <img id="photo" src="${contextPath}/${transferringStudentInfoVo.attachment}"/>
  3. </s:if>

s标签判断字符串相等

s标签数字状态翻译

  1. <s:set var="map" value="#{0:'审核中',1:'审核通过',2:'审核未通过',3:'驳回'}"></s:set>

maven

解决maven update 以后jdk还原1.5问题

  1. <build>
  2.     <finalName>cloud_talk_web</finalName>
  3.     <plugins>
  4.         <plugin>
  5.             <groupId>org.apache.maven.plugins</groupId>
  6.             <artifactId>maven-compiler-plugin</artifactId>
  7.             <version>3.1</version>
  8.             <configuration>
  9.                 <encoding>UTF-8</encoding>
  10.                 <source>1.8</source>//jdk版本
  11.                 <target>1.8</target>//jdk版本
  12.             </configuration>
  13.         </plugin>
  14.     </plugins>
  15. </build>

打包时候解决本地buildpath下的jar包问题

  1. <dependency> 
  2.     <groupId>org.apache</groupId> 
  3.     <artifactId>test</artifactId> 
  4.     <version>1.0</version> 
  5.     <scope>system</scope> 
  6.     <systemPath>${basedir}/src/main/webapp/WEB-INF/lib/paypal_base.jar</systemPath> 
  7. </dependency>

groupId和artifactId随便填写下
${basedir}变量可以直接使用
如果是多个包的话

  1. <plugin>
  2. <artifactId>maven-compiler-plugin</artifactId>
  3.   <configuration>
  4.     <source>1.6</source>
  5.     <target>1.6</target>
  6.     <encoding>UTF-8</encoding>
  7.     <!--这里引入一下-->
  8.     <compilerArguments>
  9.       <extdirs>src\main\webapp\WEB-INF\lib</extdirs>
  10.     </compilerArguments>
  11.   </configuration>
  12. </plugin>

maven引入本地jar包

公司maven上传

此处输入图片的描述

常用maven资源

  1.    <!--对long类型加密成字符串 -->
  2.     <dependency>
  3.         <groupId>org.hashids</groupId>
  4.         <artifactId>hashids</artifactId>
  5.         <version>1.0.1</version>
  6.     </dependency>
  7.     <!--更和谐的时间加减操作-->
  8.     <dependency>
  9.         <groupId>joda-time</groupId>
  10.         <artifactId>joda-time</artifactId>
  11.         <version>2.9.4</version>
  12.     </dependency>
  13.         <!-- https://mvnrepository.com/artifact/com.github.xuwei-k/html2image -->
  14.         <!--网页转图片  对css支持不太好,尽量使用css标签-->
  15.     <dependency>
  16.         <groupId>com.github.xuwei-k</groupId>
  17.         <artifactId>html2image</artifactId>
  18.         <version>0.1.0</version>
  19.     </dependency>
  20.     <!--更简洁的collection操作 -->
  21.     <dependency>
  22.         <groupId>com.google.collections</groupId>
  23.         <artifactId>google-collections</artifactId>
  24.         <version>1.0</version>
  25.     </dependency>
  26.     <!--java操作串口操作 -->
  27.     <dependency>
  28.       <groupId>org.rxtx</groupId>
  29.       <artifactId>rxtx</artifactId>
  30.       <version>2.2pre2</version>
  31.     </dependency>

struct2

action 重定向url

  1.     @Result(name = "home", type = "redirect", location = "/home")

Spring

spring注解

@PostConstruct

spring完成bean注入后执行的初始化方法,@postContruct注解的方法在构造方法执行以后执行初始化;

  1. @PostConstruct
  2.     public void init() {
  3.         dslJpaService.setEntityClass(CommonExcel.class);
  4.     }

注解@PostConstruct与@PreDestroy讲解及实例

mybatis

配置

配置控制台输出sql语句

  1. <configuration>
  2.    <settings>
  3.         ……
  4.         <setting name="logImpl" value="STDOUT_LOGGING"/>
  5.     </settings>
  6. </configuration>

mapper.xml

in查询

  1. findByIds(List<Long> ids)

xml配置

  1.  <select id="findByIdsMap" resultMap="BaseResultMap">
  2.          Select
  3.          <include refid="Base_Column_List" />
  4.          from jria where ID in
  5.                   <foreach item="item" index="index" collection="list" open="(" separator="," close=")">
  6.                         #{item}
  7.                 </foreach>
  8.   </select>
  1. findByIds(Long[] ids)

xml

  1.   <select id="findByIdsMap" resultMap="BaseResultMap">
  2.                  select
  3.                  <include refid="Base_Column_List" />
  4.           from jria where ID in
  5.                   <foreach item="item" index="index" collection="array" open="(" separator="," close=")">
  6.                         #{item}
  7.                 </foreach>
  8.   </select>

更多信息见mybatis中使用in查询时的注意事项

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注