法国项目背景要点 for Interview

几乎80%系统都会设计到person和group

group分类:

  • 永久:family,facebook,养老院,政府部门
  • 临时:旅游团队,高尔夫俱乐部,
  • 交易型:一次门诊流程设计的所有人员,交易其实也是临时,度假村

还分为

  • manual association:过滤器读取数据仓库所有表,然后根据规则过滤得到数据,点击create手动生成表
  • automatic association:过滤器读取数据仓库所有表,然后根据规则过滤得到数据,保存规则,自动生成group
  • recommended association:比如某人存在一个group中,根据group的属性自动推荐其它的group

 

Spring 事物与传播行为

  1. 业务bean加上@Transactional默认所有方法都是Propagation.REQUIRED类型,这种类型的情况,当发生unchecked Exception的时候,整个方法的业务都会回滚
  2. 如果要让checked Exception也能回滚,需要设置rollbackForClassName = {“Exception名字”}
    @Transactional(propagation = Propagation.REQUIRED, rollbackForClassName = {"Exception"})
    	public void save(Persons person) throws Exception {
    		template.update("insert into persons(name) values(?)", new Object[]{person.getName()}, new int[]{Types.VARCHAR});
    		throw new Exception();
    	}

    相应的也可以让runtimeException不回滚的属性noRollbackForClassName,比如配上runtimeException,那么runtimeException就不会回滚了
  3. 在增删改里面,特别是一个业务bean里面有多个dao增删改操作是需要使用事物,但在查询方法里面,没有必要使用事物,可以用Propagation.NOT_SUPPORTED表示这个方法不支持事物
  4. readOnly:一般是查询方法使用,用了NOT_SUPPORTED就不需要用这个属性
  5. timeout:事物的超时时间,默认30秒
  6. isolate:数据库的隔离级别

事物的传播属性:

  • REQUIRED:表示如果方法运行时已经在一个事物中,那么就会加入这个事物,如果没有在事物中,就新起一个事物

    比如说,ServiceB.methodB的事务级别定义为PROPAGATION_REQUIRED, 那么由于执行ServiceA.methodA的时候,

    ServiceA.methodA已经起了事务,这时调用ServiceB.methodB,ServiceB.methodB看到自己已经运行在ServiceA.methodA

    的事务内部,就不再起新的事务。而假如ServiceA.methodA运行的时候发现自己没有在事务中,他就会为自己分配一个事务。

    这样,在ServiceA.methodA或者在ServiceB.methodB内的任何地方出现异常,事务都会被回滚。即使ServiceB.methodB的事务已经被

    提交,但是ServiceA.methodA在接下来fail要回滚,ServiceB.methodB也要回滚

  • NOT_SUPPORTED:表示方法内不会启动事物,如果在其他事物方法里面调用这个方法,那个事物方法里面的事物将被挂起,直到NOT_SUPPORTED方法完成后才恢复。
  • REQUIRED_NEW:不管是否存在事物,都会开启一个新事物,如果已经开启一个事物,原有的事物会被挂起直到REQUIRED_NEW的方法调用结束原事物猜恢复

    比如:如我们设计ServiceA.methodA的事务级别为PROPAGATION_REQUIRED,ServiceB.methodB的事务级别为PROPAGATION_REQUIRES_NEW,

    那么当执行到ServiceB.methodB的时候,ServiceA.methodA所在的事务就会挂起,ServiceB.methodB会起一个新的事务,等待ServiceB.methodB的事务完成以后,

    他才继续执行。他与PROPAGATION_REQUIRED 的事务区别在于事务的回滚程度了。因为ServiceB.methodB是新起一个事务,那么就是存在

    两个不同的事务。如果ServiceB.methodB已经提交,那么ServiceA.methodA失败回滚,ServiceB.methodB是不会回滚的。如果ServiceB.methodB失败回滚,

    如果他抛出的异常被ServiceA.methodA捕获,ServiceA.methodA事务仍然可能提交。

  • MANDATORY:MANDATORY方法只能在存在事物的方法中被调用,否则会抛出异常
  • SUPPORTS:业务方法被事物方法调用,业务方法成为原方法事物的一部分,如果被非事物方法调用,则方法在没有事物的环境下执行
  • NEVER:不能在事物方法中被调用,否则会抛出异常
    设ServiceA.methodA的事务级别是PROPAGATION_REQUIRED, 而ServiceB.methodB的事务级别是PROPAGATION_NEVER ,
    那么ServiceB.methodB就要抛出异常了。
  • NESTED:如果活动的事物存在,会运行在这个嵌套事务中,如果没有活动事物,就按照REQUIRED来执行,内部的这个NESTED事物回滚不影响外部事物,只对DataSourceTransactionManager这个事物配置类起作用
    比如
    update1();
    update2(); — NESTED
    update3();
    如果update2()失败回滚,update1,update3将还是会正常执行

Spring 配置文件实现AOP

public class MyInterceptorWithoutAnnotation {

	public void beforeAdvice(){
		System.out.println("前置通知");
	}

	public void afterAdvice(){
		System.out.println("后置通知");
	}

	public void finalAdvice(){
		System.out.println("最终通知");
	}

	public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable{
		Users user = new Users();
		try {
			System.out.println("环绕通知");
			if (!"".equals(user.getName())) {
				return pjp.proceed();
			}
		} catch (Throwable e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd
           http://www.springframework.org/schema/aop
           http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
       <!--context:component-scan base-package="com.practise.spring" /-->
       <aop:aspectj-autoproxy />
       <bean id="personDao" class="com.practise.spring.dao.impl.PersonDao" />
       <bean id="personService" class="com.practise.spring.service.impl.PersonServiceImpl">
           <property name="personDao" ref="personDao"></property>
       </bean>
       <bean id="myInterceptor" class="com.practise.spring.interceptor.MyInterceptorWithoutAnnotation" />
       
       <aop:config>
           <aop:aspect id="asp" ref="myInterceptor">
               <aop:pointcut expression="execution(* com.practise.spring.service.impl.PersonServiceImpl.*(..))" id="mycut"/>
               <aop:before pointcut-ref="mycut" method="beforeAdvice"/>
               <aop:after-returning pointcut-ref="mycut" method="afterAdvice"/>
               <aop:after pointcut-ref="mycut" method="finalAdvice"/>
               <aop:around pointcut-ref="mycut" method="aroundAdvice"/>
           </aop:aspect>
       </aop:config>
</beans>

Spring 依赖注入的多种方式

Spring bean依赖注入的方式:

1. 通过构造器注入:

<bean id="userService" class="com.practise.spring.service.impl.UserServiceImpl" lazy-init="true">
           <constructor-arg index="0" type="com.practise.spring.dao.IPersonDao" ref="personDao"></constructor-arg>
       </bean>

2. 通过ref方式注入
<bean id="personDao" class="com.practise.spring.dao.impl.PersonDao" />
       <bean id="personService" class="com.practise.spring.service.impl.PersonServiceImpl" lazy-init="true" init-method="init" destroy-method="close">
           <property name="personDao" ref="personDao"></property>
       </bean>

3. 内部bean
<bean id="personService" class="com.practise.spring.service.impl.PersonServiceImpl" lazy-init="true" init-method="init" destroy-method="close">
           <property name="personDao">
                  <bean class="com.practise.spring.dao.impl.PersonDao" />
            </property>
       </bean>

Spring Bean的作用域和生命周期

Bean的作用域:

  • singleton:默认scope,每次取得的都是相同的实例,在spring容器启动的时候就实例化所有配置的bean
  • prototype:scope=”prototype”,每次取得的都是新实例,在getBean的时候才真正的实例化
  • request
  • session
  • global session

Bean的生命周期

  • 默认是spring容器启动,所有bean就实例化
  • 设置lazy-init=”true”:getBean时才实例化bean,相反false的话就是容器启动,所有bean实例化
  • <beans default-lazy-init=”true”>:为所有bean设置延迟初始化
  • init-method=”init”:加上这个属性,如果是延迟加载,getBean调用的时候会先实例化然后再马上调用初始化方法init
  • destroy-method=”close”:加上这个属性,当spring的context.close()调用时,会执行close方法

 

DsoFramer word,excel只读和ppt自动阅览功能(web版)

Js版:

Mysql 重新安装遇到的问题

当安装到Mysql 最后一步execute的时候:
出现“could not start the service”的问题。
解决方案:停用Mysql的服务,然后在MySQL的bin目录下执行“mysqld-nt -remove”再重新execute(execute中第三步就可以通过)
出现“mysql Apply security setting Error Nr 1045”
解决方案:
1.到控制面板里面先把mysql删除.
2.到c盘C:/Program Files目录下把mysql目录删除.
3.如果在其他盘还有设置目录也要删除.空目录也要删除,最好全盘搜索下(c:用户/我的文档/Navicat/MySQL和MySQL安装目录首先需要删除)
4.到regedit把注册表
HKEY_LOCAL_MACHINE/SYSTEM/ControlSet001/Services/Eventlog/Applications/MySQL
HKEY_LOCAL_MACHINE/SYSTEM/ControlSet002/Services/Eventlog/Applications/MySQL
HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/Eventlog/Applications/MySQL
其他的最好也ctrl + f 然后全删除了
5.如果任务管理器里有关mysql内容也删除
6.把防火墙关了
7.重新装mysql(这里我没有重启计算机)

Merge two different Dom

如果有两个dom结构的document,想要直接将B document append到A document里面会提示错误:
org.w3c.dom.DOMException: WRONG_DOCUMENT_ERR: A node is used in a different document than the one that created it.
正确的方法是:
private Document buildACK(List resynDocList) throws ParserConfigurationException {
if (!this.successDoc && this.sucess()) {
return null;
}

Document ackDoc = DocumentBuilderFactory.newInstance()
.newDocumentBuilder().newDocument();
Element response = ackDoc.createElement(“Response”);
ackDoc.appendChild(response);
// modify to set real resyn documents start
/*Element requestID = ackDoc.createElement(“RequestID”);
if (uuid != null) {
requestID.setTextContent(uuid.toString());
}
response.appendChild(requestID);*/

for(Document resynDoc : resynDocList){
Element resynElement = resynDoc.getDocumentElement();
Node importedResynNode = ackDoc.importNode(resynElement, true);
response.appendChild(importedResynNode);
}
// modify to set real resyn documents end

Element responseCodeEle = ackDoc.createElement(“ResponseCode”);
responseCodeEle.setTextContent(Integer.toString(responseCode));
response.appendChild(responseCodeEle);

Element message = ackDoc.createElement(“Message”);

if (responseMsg == null) {
message.setTextContent(“Command has been executed succesfully.”);
} else {
message.setTextContent(responseMsg);
}

response.appendChild(message);
return ackDoc;
}
正确的方法,使用import将B document导入到A document的结构中