水灵动
水灵动

Spring事务处理的实现

一、事务概览

TransactionProxyFactoryBean：生成代理对象，通过TransactionInterceptor拦截代理方法。

具体到事务的生成、提交、回滚、挂起，需要适配应用指定的数据源对应事务处理，如DataSourceTransactionManager。

二、事务的应用场景

编码式事务：（控制狂）

public void testTransaction() {
    //创建TransactionDefinition
    TransactionDefinition definition = new DefaultTransactionDefinition();
    //通过TransactionManager.getTransaction→TransactionStatus
    TransactionStatus transactionStatus = transactionManager.getTransaction(definition);
    try {
        insertContacter();
        throwException();
        //事务正常结束，transactionManager调用commit，传transactionStatus，
        transactionManager.commit(transactionStatus);
    } catch (Exception e) {
        logger.error("throw exception, need rollback", e);
        //抛出异常，回滚
        transactionManager.rollback(transactionStatus);
    }
}
 
private int throwException() throws Exception {
    return 1/0;
}


 
   编码式事务是代码有侵入性的，只有在需要精细到代码行，才需要编码式事务。 
  
 
  
 声明式事务：（非控制狂）
 
  
 通过AOP，将为事务作为切面，对应用方法进行增强。《Spring AOP实现原理》
 
  
 方式一：使用xml配置/事务
 
  
 
 
  


 
    
    
 
    
    
        
    
 
    
        
            
        
    
     
    
        
               
         

 
  
 方式二：使用注解@Transaction
 
  
 
 
  




    

 
  
 并在目标类或方法上加@Transaction， 
  不建议将注解加载接口上，因为注解是不继承的。 
  
 声明式事务以方法粒度为事务边界。较编码式事务，包含Spring事务管理、并发事务、事务属性及框架整合相关内容，通过声明式事务划分+IoC配置，为应用提供了统一的事务处理方案。
 
  
 三、事务属性
 
  
 3.1 隔离级别：
 
  
 1. ISOLATION_DEFAULT： 默认的隔离级别，使用使用数据库默认的事务隔离级别库。大部分数据库默认的隔离级别是：ISOLATION_READ_COMMITTED
 
  
 2. ISOLATION_READ_UNCOMMITTED：这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
 
  
 3. ISOLATION_READ_COMMITTED：保证一个事务修改的数据提交后才能被另外一个事务读取。
 
  
 
 
  
 4. ISOLATION_REPEATABLE_READ：A事务开启后，其他事务对数据的修改，在当前不可见。即本事务重复读数据始终一致，除非是当前的修改。这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。（Innodb的重复读，不会出现幻读）
 
  
 5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。
 
  
 ps：
 
  
     
   
  • 脏读：访问了别的事务未提交的数据。
    •  
   
  • 不可重复读：A事务两次读同一数据，期间数据被B修改，导致A前后两次读的数据不一致。
    •  
   
  • 幻读: 指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。(部分不在事务锁范围的数据，不被事务感知）
    •  
  
 
  
 3.2 传播机制：
 
  
     
   
  • PROPAGATION_REQUIRED：支持当前事务，如果当前没有事务，就新建一个事务：0。 
    •  
   
  • PROPAGATION_SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行：1。 
    •  
   
  • PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常：2。 
    •  
   
  • PROPAGATION_REQUIRES_NEW：新建事务，如果当前存在事务，把当前事务挂起：3。 
    •  
   
  • PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起：4。 
    •  
   
  • PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常：5。 
    •  
   
  • PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作：6。
     1：默认值，最常用；2-4：相反；3-5：相反；
    •  
  
 
  
 3.3 超时（事务的超时时间设置：statement执行时间 * n + (n-1) * 执行间隙时间？）
 
  
 TransactionManager设置TransactionDefinition定义的事务超时时间
 
  
 
 
  
@Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
   ...
      int timeout = determineTimeout(definition);
      if (timeout != TransactionDefinition.TIMEOUT_DEFAULT) {
         txObject.getConnectionHolder().setTimeoutInSeconds(timeout);
      }
   ...
}
 
  
 设置deadline，当前时间+超时时间(ms)，即当前时间为开始时间 
  
 
 
  
public void setTimeoutInSeconds(int seconds) {
   setTimeoutInMillis(seconds * 1000);
}
public void setTimeoutInMillis(long millis) {
   this.deadline = new Date(System.currentTimeMillis() + millis);
}
 
  
 运用超时时间：
 
  
 
 
  
protected void applyStatementSettings(Statement stmt) throws SQLException {
   int fetchSize = getFetchSize();
   if (fetchSize >= 0) {
      stmt.setFetchSize(fetchSize);
   }
   int maxRows = getMaxRows();
   if (maxRows >= 0) {
      stmt.setMaxRows(maxRows);
   }
   DataSourceUtils.applyTimeout(stmt, getDataSource(), getQueryTimeout());
}
 
  
 
 
  
public static void applyTimeout(Statement stmt, DataSource dataSource, int timeout) throws SQLException {
   Assert.notNull(stmt, "No Statement specified");
   Assert.notNull(dataSource, "No DataSource specified");
   ConnectionHolder holder = (ConnectionHolder) TransactionSynchronizationManager.getResource(dataSource);
   if (holder != null && holder.hasTimeout()) {
      // 已经存在超时时间，则更新为剩余有效时间
      stmt.setQueryTimeout(holder.getTimeToLiveInSeconds());
   }
   else if (timeout >= 0) {
      // 当前不存在超时时间，设置
      stmt.setQueryTimeout(timeout);
   }
}
 
  
 获取当前剩余有效时间，若deadline-当前时间不大于0（即便是0.0001s），则回滚，抛出超时异常。
 
  
 
 
  
public int getTimeToLiveInSeconds() {
   double diff = ((double) getTimeToLiveInMillis()) / 1000;
   int secs = (int) Math.ceil(diff);
   checkTransactionTimeout(secs <= 0);
   return secs;
}
private void checkTransactionTimeout(boolean deadlineReached) throws TransactionTimedOutException {
   if (deadlineReached) {
      setRollbackOnly();
      throw new TransactionTimedOutException("Transaction timed out: deadline was " + this.deadline);
   }
}
 
  
 综上，Spring事务超时 = 事务开始时到最后一个Statement创建时时间 + 最后一个Statement的执行时超时时间。因此，如果在最后一个语句前，含有远程调用，可能会引发超时，而在事务之后不会。
 
  
 DafaultTransactionDefinition默认超时时间为-1，即没有超时时间。不设置超时时间是有风险的，可能导致连接被阻塞。（默认：30s？）
 
  
 3.4 只读状态
 
  
 事务处理中，是否仅涉及读操作。设置事务『只读』状态，可提高事务并发。默认值：false。
 
  
 四、设计原理与基本过程
 
  
 
 
  
 Spring事务处理简单类图
 
  
 
 
  
 TransactionAttributeSourceAdvisor：事务属性通知器，处理事务属性值，结果TransactionAttribute对象，注入IoC容器。
 
  
 TransactionProxyFactoryBean
 
  
 
 
  
public class TransactionProxyFactoryBean extends AbstractSingletonProxyFactoryBean
      implements BeanFactoryAware {
    //通过Spring的AOP，使用TransactionInterceptor实现事务处理
   private final TransactionInterceptor transactionInterceptor = new TransactionInterceptor();
   private Pointcut pointcut;
    //拦截器设置注入的事务管理器
   public void setTransactionManager(PlatformTransactionManager transactionManager) {
      this.transactionInterceptor.setTransactionManager(transactionManager);
   }
   //将注入的事务属性设置到拦截器
   public void setTransactionAttributes(Properties transactionAttributes) {
      this.transactionInterceptor.setTransactionAttributes(transactionAttributes);
   }
   public void setTransactionAttributeSource(TransactionAttributeSource transactionAttributeSource) {
      this.transactionInterceptor.setTransactionAttributeSource(transactionAttributeSource);
   }
   public void setPointcut(Pointcut pointcut) {
      this.pointcut = pointcut;
   }
   @Override
   public void setBeanFactory(BeanFactory beanFactory) {
      this.transactionInterceptor.setBeanFactory(beanFactory);
   }
    //在IoC容器初始化Bean时被调用，创建通知器，并配置拦截器
   @Override
   protected Object createMainInterceptor() {
      this.transactionInterceptor.afterPropertiesSet();
      if (this.pointcut != null) {
         return new DefaultPointcutAdvisor(this.pointcut, this.transactionInterceptor);
      }
      else {
         // 没有切点，使用TransactionAttributeSourceAdvisor作为通知器.
         return new TransactionAttributeSourceAdvisor(this.transactionInterceptor);
      }
   }
   @Override
   protected void postProcessProxyFactory(ProxyFactory proxyFactory) {
      proxyFactory.addInterface(TransactionalProxy.class);
   }
}
 
  
 继承自AbstractSingletonProxyFactoryBean的afterPropertiesSet方法，为ProxyFactory生成代理对象、配置通知器、设置代理接口方法。
 
  
  
 
  
 TransactionInterceptor
 
  
 使用正则等匹配规则，匹配切点：注入时配置事务属性，保存一个在nameMap；方法调用时，从nameMap匹配方法名，查询事务属性，如果存在，则对其进行拦截。
 
  
 TransactionAttributeSource
 
  
 
 
  
@Override
public TransactionAttribute getTransactionAttribute(Method method, Class targetClass) {
   if (!ClassUtils.isUserLevelMethod(method)) {
      return null;
   }
 
   // Look for direct name match.
   String methodName = method.getName();
   TransactionAttribute attr = this.nameMap.get(methodName);
 
   if (attr == null) {
      // Look for most specific name match.
      String bestNameMatch = null;
      for (String mappedName : this.nameMap.keySet()) {
         if (isMatch(methodName, mappedName) &&
               (bestNameMatch == null || bestNameMatch.length() <= mappedName.length())) {
            attr = this.nameMap.get(mappedName);
            bestNameMatch = mappedName;
         }
      }
   }
 
   return attr;
}
 
  
 TransactionAspectSupport
 
  
protected Object invokeWithinTransaction(Method method, Class targetClass, final InvocationCallback invocation)
      throws Throwable {
   // 匹配事务属性，若为null，则非事务方法
   final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
   final PlatformTransactionManager tm = determineTransactionManager(txAttr);
   final String joinpointIdentification = methodIdentification(method, targetClass);
 
   if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
      // Standard transaction demarcation with getTransaction and commit/rollback calls.
      TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
      Object retVal = null;
      try {
         // This is an around advice: Invoke the next interceptor in the chain.
         // This will normally result in a target object being invoked.
         retVal = invocation.proceedWithInvocation();
      }
      catch (Throwable ex) {
         // target invocation exception
         completeTransactionAfterThrowing(txInfo, ex);
         throw ex;
      }
      finally {
         cleanupTransactionInfo(txInfo);
      }
      commitTransactionAfterReturning(txInfo);
      return retVal;
   }
 
   else {
      // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
      try {
         Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
               new TransactionCallback() {
                  @Override
                  public Object doInTransaction(TransactionStatus status) {
                     TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                     try {
                        return invocation.proceedWithInvocation();
                     }
                     catch (Throwable ex) {
                        if (txAttr.rollbackOn(ex)) {
                           // A RuntimeException: will lead to a rollback.
                           if (ex instanceof RuntimeException) {
                              throw (RuntimeException) ex;
                           }
                           else {
                              throw new ThrowableHolderException(ex);
                           }
                        }
                        else {
                           // A normal return value: will lead to a commit.
                           return new ThrowableHolder(ex);
                        }
                     }
                     finally {
                        cleanupTransactionInfo(txInfo);
                     }
                  }
               });
 
         // Check result: It might indicate a Throwable to rethrow.
         if (result instanceof ThrowableHolder) {
            throw ((ThrowableHolder) result).getThrowable();
         }
         else {
            return result;
         }
      }
      catch (ThrowableHolderException ex) {
         throw ex.getCause();
      }
   }
} 
  TransactionInterceptor 
  
 
 
  
@Override
public Object invoke(final MethodInvocation invocation) throws Throwable {
   // Work out the target class: may be {@code null}.
   // The TransactionAttributeSource should be passed the target class
   // as well as the method, which may be from an interface.
   Class targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);
 
   // Adapt to TransactionAspectSupport's invokeWithinTransaction...
   return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
      @Override
      public Object proceedWithInvocation() throws Throwable {
         return invocation.proceed();
      }
   });
}
 
  
 
PlatformTransactionManager
 
  
 
 
  
public final TransactionStatus getTransaction(TransactionDefinition definition) throws TransactionException {
   //由具体数据源对应的事务管理器实现
   Object transaction = doGetTransaction();
   // 局部变量，缓存debug标识，不需要重复查询
   boolean debugEnabled = logger.isDebugEnabled();
   if (definition == null) {
      // 使用默认的事务定义
      definition = new DefaultTransactionDefinition();
   }
   //是否已存在事务
   if (isExistingTransaction(transaction)) {
      // 根据事务传播属性决定后续处理，看传播属性重点看这里.
      return handleExistingTransaction(definition, transaction, debugEnabled);
   }
   // 超时时间不允许<-1
   if (definition.getTimeout() < TransactionDefinition.TIMEOUT_DEFAULT) {
      throw new InvalidTimeoutException("Invalid transaction timeout", definition.getTimeout());
   }
   // 不允许当前不存在事务（PROPAGATION_MANDATORY：支持当前事务，如果当前没有事务，就抛出异常：2。）
   if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_MANDATORY) {
      throw new IllegalTransactionStateException(
            "No existing transaction found for transaction marked with propagation 'mandatory'");
   }
   else if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRED ||
         definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW ||
         definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NESTED) {
        //事务挂起
      SuspendedResourcesHolder suspendedResources = suspend(null);
      if (debugEnabled) {
         logger.debug("Creating new transaction with name [" + definition.getName() + "]: " + definition);
      }
      try {
         boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
         DefaultTransactionStatus status = newTransactionStatus(
               definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        //开启事务
         doBegin(transaction, definition);
         prepareSynchronization(status, definition);
         return status;
      }
      catch (RuntimeException ex) {
         resume(null, suspendedResources);
         throw ex;
      }
      catch (Error err) {
         resume(null, suspendedResources);
         throw err;
      }
   }
   else {
      // Create "empty" transaction: no actual transaction, but potentially synchronization.
      if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT && logger.isWarnEnabled()) {
         logger.warn("Custom isolation level specified but no actual transaction initiated; " +
               "isolation level will effectively be ignored: " + definition);
      }
      boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
      return prepareTransactionStatus(definition, null, true, newSynchronization, debugEnabled, null);
   }
}
 
  
SuspendedResourcesHolder suspendedResources = suspend(null);
 
  
 
  
protected final SuspendedResourcesHolder suspend(Object transaction) throws TransactionException {
   if (TransactionSynchronizationManager.isSynchronizationActive()) {
      List suspendedSynchronizations = doSuspendSynchronization();
      try {
         Object suspendedResources = null;
         if (transaction != null) {
            suspendedResources = doSuspend(transaction);
         }
         String name = TransactionSynchronizationManager.getCurrentTransactionName();
         TransactionSynchronizationManager.setCurrentTransactionName(null);
         boolean readOnly = TransactionSynchronizationManager.isCurrentTransactionReadOnly();
         TransactionSynchronizationManager.setCurrentTransactionReadOnly(false);
         Integer isolationLevel = TransactionSynchronizationManager.getCurrentTransactionIsolationLevel();
         TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(null);
         boolean wasActive = TransactionSynchronizationManager.isActualTransactionActive();
         TransactionSynchronizationManager.setActualTransactionActive(false);
        //以上每一步操作均返回原事务对应的属性，最后用SuspendedResourcesHolder包装，返回，是为了保留事务现场，以便重新唤醒。
         return new SuspendedResourcesHolder(
               suspendedResources, suspendedSynchronizations, name, readOnly, isolationLevel, wasActive);
      }
      catch (RuntimeException ex) {
         // doSuspend failed - original transaction is still active...
         doResumeSynchronization(suspendedSynchronizations);
         throw ex;
      }
      catch (Error err) {
         // doSuspend failed - original transaction is still active...
         doResumeSynchronization(suspendedSynchronizations);
         throw err;
      }
   }
   else if (transaction != null) {
      // Transaction active but no synchronization active.
      Object suspendedResources = doSuspend(transaction);
      return new SuspendedResourcesHolder(suspendedResources);
   }
   else {
      // Neither transaction nor synchronization active.
      return null;
   }
}
//唤醒被挂起的事务
protected final void resume(Object transaction, SuspendedResourcesHolder resourcesHolder)
      throws TransactionException {
 
   if (resourcesHolder != null) {
      Object suspendedResources = resourcesHolder.suspendedResources;
      if (suspendedResources != null) {
         doResume(transaction, suspendedResources);
      }
      List suspendedSynchronizations = resourcesHolder.suspendedSynchronizations;
      if (suspendedSynchronizations != null) {
         TransactionSynchronizationManager.setActualTransactionActive(resourcesHolder.wasActive);
         TransactionSynchronizationManager.setCurrentTransactionIsolationLevel(resourcesHolder.isolationLevel);
         TransactionSynchronizationManager.setCurrentTransactionReadOnly(resourcesHolder.readOnly);
         TransactionSynchronizationManager.setCurrentTransactionName(resourcesHolder.name);
         doResumeSynchronization(suspendedSynchronizations);
      }
   }
}
 
  AbstractPlatformTransactionManager.processRollback 
  
 
  
private void processRollback(DefaultTransactionStatus status) {
   try {
      try {
         triggerBeforeCompletion(status);
         if (status.hasSavepoint()) {
            if (status.isDebug()) {
               logger.debug("Rolling back transaction to savepoint");
            }
            status.rollbackToHeldSavepoint();
         }
         else if (status.isNewTransaction()) {
            if (status.isDebug()) {
               logger.debug("Initiating transaction rollback");
            }
            doRollback(status);
         }
         else if (status.hasTransaction()) {
            if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
               if (status.isDebug()) {
                  logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
               }
               doSetRollbackOnly(status);
            }
            else {
               if (status.isDebug()) {
                  logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
               }
            }
         }
         else {
            logger.debug("Should roll back transaction but cannot - no transaction available");
         }
      }
      catch (RuntimeException ex) {
         triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
         throw ex;
      }
      catch (Error err) {
         triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
         throw err;
      }
      triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);
   }
   finally {
      cleanupAfterCompletion(status);
   }
}
 
  
 TransactionDefinition：定义事务属性，有默认实现类DefaultTransactionDefinition。
 
  
 DefaultTransactionDefinition
 
  
 
 
  
//传播机制：支持事务，若不存在，则新建事务
private int propagationBehavior = PROPAGATION_REQUIRED;
//隔离级别：默认使用数据库的隔离级别，大部分数据库为提交读，mysql：可重复读
private int isolationLevel = ISOLATION_DEFAULT;
//超时时间，默认值-1
private int timeout = TIMEOUT_DEFAULT;
//是否只读，默认值非只读
private boolean readOnly = false;
 
   
  
 TransactionStatus、TransactionInfo：作为事务上下文变量，与线程绑定，传递事务状态信息。
 
  
 TransactionStatus
 
  
 
 
  
public interface TransactionStatus extends SavepointManager, Flushable {
   //是否新事务
   boolean isNewTransaction();
   //在嵌套事务中，用于事务建传递的保存点
   boolean hasSavepoint();
   //标记为回滚
   void setRollbackOnly();
   //是否标记为回滚
   boolean isRollbackOnly();
   @Override
   void flush();
   //是否已完成：提交or回滚
   boolean isCompleted();
}
 
  TransactionInfo 
  
 
 
  
//TransactionAspectSupport的内部类
protected final class TransactionInfo {
   private final PlatformTransactionManager transactionManager;
   private final TransactionAttribute transactionAttribute;
   private final String joinpointIdentification; //切点标识
   private TransactionStatus transactionStatus;
   private TransactionInfo oldTransactionInfo; //栈特性，保存老事务，在当前事务结束后，恢复老事务为当前事务
...
}
 
  
 五、实践笔记
 
  
 1. TException抛出的异常无法直接获取错误信息，因此需要包装到response。那么，就需要catch异常，这会导致原本依赖抛出异常回滚的AOP事务，将无法回滚，需要显示调用回滚：
 
  
 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
 
  
 2. @Transaction注解只有在public方法，且调用发生类间才有效；
 
  
 3. 嵌套事务，子事务需要回滚，是通过设置全局isRollBackOnly变量，直到最外层事务，才被回滚；
 
  
 4. 如何查看调用链：使用ctrl+alter+H，调出调用面板
 
  
 
 
  
 5. Mysql终端使用事务
 
  
 
 
  
//方法一：
//查看自动提交状态
show variables like 'autocommit' or
select @@autocommit
set autocommit = 0
delete from contract_contacter where id = 2673
commit or rollback
  
//方法二：
begin
delete from contract_contacter where id = 2673
rollback or commit
 
  
 6. 获取线程变量
 
  
 
 
  
public T get() {
    Thread t = Thread.currentThread();
    //从当前线程取出线程变量ThreadLocalMap
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        //map中取出调用者所对应的value
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    //若不存在，则返回空
    return setInitialValue();
}
  
  
 参考文献：
 
  
 深入理解JDBC的超时设置 http://www.importnew.com/2466.html
 
  
 MYSQL（innodb）锁与隔离级别 http://mit.sankuai.com/activity/#/9934
 
  
 
   
 
  
 
  
 
   
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(web开发框架)

        

            

                
    
                    
  • Python WebSocket服务器介绍
                        一只会写程序的猫
Pythonpythonwebsocket服务器
                        
    PythonWebSocket服务器介绍WebSocket是一种在Web浏览器和服务器之间实现全双工通信的协议。它允许服务器主动发送消息到浏览器，而不需要浏览器发起请求。Python提供了许多库和框架来实现WebSocket服务器，本文将介绍如何使用Python构建一个简单的WebSocket服务器。WebSocket协议和工作原理WebSocket协议是通过HTTP协议的升级实现的。在HTTP协
    
                    
    • 
                    
  • python注册nacos服务
                        MTonj
Pythonpython开发语言
                        
    根据nacosopenapiOpenAPI指南主要是实现以下接口：创建服务注册实例注销实例删除服务发送实例心跳实现demo如下：一个web服务1http_server1.py#coding:utf-8importsocketfrommultiprocessingimportProcessdefhandle_client(client_socket):"""处理客户端请求"""request_dat
    
                    
    • 
                    
  • 用Python进行websocket接口测试
                        代码小念
软件测试自动化测试技术分享pythonwebsocket开发语言
                        
    这篇文章主要介绍了用Python进行websocket接口测试，帮助大家更好的理解和使用python，感兴趣的朋友可以了解下我们在做接口测试时，除了常见的http接口，还有一种比较多见，就是socket接口，今天讲解下怎么用Python进行websocket接口测试。SocketSocket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可
    
                    
    • 
                    
  • 标准化可观察量：Web标准新成员及其与RxJS的差异
                        exploration-earth
前端javascript开发语言
                        
    当前，可观察对象（乃至信号）正逐步成为Web标准体系不可或缺的一部分，这一趋势不仅预示着Web开发技术的进一步成熟与规范化，也为开发者们提供了更加统一、高效的编程接口。相较于RxJS这一流行的响应式编程库中的Observables，标准化的可观察量在设计理念与实现细节上均展现出若干显著的不同点，这些差异旨在更好地适应Web环境的特殊需求，提升开发效率与代码的可维护性。具体而言，标准化后的可观察量可
    
                    
    • 
                    
  • 【spring boot统一功能处理】拦截器
                        一只淡水鱼66
JavaEEspringbootjava后端拦截器
                        
    拦截器在SpringBoot中，拦截器（Interceptor）是用于在处理请求前后进行一些自定义操作的组件，常用于日志记录、权限检查、性能监控等。拦截器的使用依赖于HandlerInterceptor接口和WebMvcConfigurer接口。1.HandlerInterceptor接口HandlerInterceptor接口是SpringMVC中用来定义拦截器的核心接口。它有三个方法需要实现：
    
                    
    • 
                    
  • 使用 Python 实现 WebSocket 服务器与客户端通信
                        又蓝
pythonwebsocket
                        
    简介WebSocket是一种基于TCP协议的通信协议，能够在客户端与服务器之间进行全双工（双向）通信。相比传统的HTTP协议，WebSocket可以实现实时数据的传输，尤其适合需要实时交互的应用场景，如在线游戏、实时聊天、金融交易等。我通过Python实现一个简单的WebSocket服务器，并使其与客户端进行通信。我们将创建两个Python文件：websocket.py和main.py，webso
    
                    
    • 
                    
  • 【如何利用Python抢演唱会门票】python利用selenium实现大麦网抢票
                        Python小炮车
pythonselenium数据库
                        
    一、selenium原理介绍Selenium是一个用于Web[应用程序](https://link.juejin.cn/?target=https%3A%2F%2Fbaike.baidu.com%2Fitem%2F%25E5%25BA%2594%25E7%2594%25A8%25E7%25A8%258B%25E5%25BA%258F%2F5985445%3FfromModule%3Dlemma_i
    
                    
    • 
                    
  • 麒麟操作系统服务架构保姆级教程（十一）https配置
                        小屁不止是运维
系统架构架构https网络协议linux运维LNMP服务器
                        
    如果你想拥有你从未拥有过的东西，那么你必须去做你从未做过的事情在运维工作中，加密和安全的作用是十分重要的，如果仅仅用http协议来对外展示我们的网站，过一段时间就会发现网站首页被人奇奇怪怪的篡改了，本来好好的博客论坛，被人篡改的五毒俱全，这个时候我们的网站就需要加密访问了，这个加密不是说要密码才可以查看网站，而是通过https协议进行加密访问，客户端进行访问的时候会进行加密和解密，防止我们的web
    
                    
    • 
                    
  • java3d酷眩贪吃蛇下载,100行JS实现HTML5的3D贪吃蛇游戏
                        weixin_39983554
java3d酷眩贪吃蛇下载
                        
    js1k.com收集了小于1k的javascript小例子，里面有很多很炫很酷的游戏和特效，今年规则又增加了新花样，传统的classic类型基础上又增加了WebGL类型，以及允许增加到2K的++类型，多次想尝试提交个小游戏但总无法写出让自己满意还能控制在这么小的字节范围。自己写不出来，站在巨人肩膀总是有机会吧，折腾了一番站在Hightopo的肩膀上搞了个3D贪吃蛇游戏，算了算JS代码还只有90来行
    
                    
    • 
                    
  • Android开发中图片处理
                        wayne214
android
                        
    图片优化：选择合适的图片格式：使用适当的图片格式（如PNG、JPEG或WebP）以获得最佳的图片质量和文件大小。通常，JPEG用于具有丰富颜色和细节的图片，PNG用于需要透明度的图片，而WebP则结合了JPEG和PNG的优点，且具有更小的文件大小。压缩图片：在不损失图像质量的前提下尽可能减小图像文件大小。可以使用AndroidStudio的ImageAssetStudio工具或在线工具（如Tiny
    
                    
    • 
                    
  • Servlet中配置和使用过滤器
                        幽兰的天空
Java基础启航：从零到小有所成Servlet技术servlethivehadoop
                        
    在Servlet中配置和使用过滤器主要包括创建过滤器类、配置过滤器以及在Web应用中使用过滤器等步骤，以下是具体内容：创建过滤器类过滤器类需要实现javax.servlet.Filter接口，并重写其中的init、doFilter和destroy方法。init方法用于过滤器的初始化，在服务器启动时被调用，通常用于加载配置文件、初始化资源等操作。doFilter方法是过滤器的核心方法，用于实现具体的
    
                    
    • 
                    
  • Node.js - Express框架
                        蒜蓉大猩猩
Node.jsnode.jsexpress后端架构
                        
    1.介绍Express是一个基于Node.js的Web应用程序框架，主要用于快速、简便地构建Web应用程序和API。它是目前最流行的Node.jsWeb框架之一，具有轻量级、灵活和功能丰富的特点。核心概念包括路由，中间件，请求与响应，以及模板引擎支持2.Express应用的使用通过npm进行安装express包npminstallexpress示例：以下是一个最简单的Express应用程序cons
    
                    
    • 
                    
  • .net链接mysql简单而高效
                        天堂镇的幽灵
.netmysqlandroid
                        
    usingSystem;usingSystem.Collections.Generic;usingSystem.Data.SqlClient;usingSystem.Data;usingSystem.Linq;usingSystem.Web;usingMySql.Data;usingMySql.Data.MySqlClient;usingSystem.Configuration;namespace
    
                    
    • 
                    
  • flowable-ui 在tomcat中启动
                        xunbaogang
uitomcatjava
                        
    使用原因：本地电脑通过命令启动flowable-ui.jar无法启动，总是提示锁定状态临时处理场景：通过阿里云租了一个月的云服务，云服务器使用centos系统，在云服务器中可以启动本地处理场景：本地使用：web服务程序：apache-tomcat-8.5.91数据库：mysql8.0.30flowable版本：flowable-6.8.0最后一个带ui的程序使用问题：直接启动时，提示缺少驱动，驱动
    
                    
    • 
                    
  • Spring Boot入门(19)：超酷炫！Spring Boot + Thymeleaf 带你玩转 Web 页面开发！
                        喵手
Springbootspringboot前端后端
                        
    前言在Web开发中，不管是MVC框架还是前后端分离，都需要使用模板引擎来渲染生成页面。Thymeleaf是一款非常优秀的模板引擎，它以自然的方式处理模板，支持HTML5标签，同时兼容HTML4。本文将介绍如何使用SpringBoot框架，整合Thymeleaf模板引擎来开发Web页面。摘要本文将分为以下几个部分:新建SpringBoot项目配置Thymeleaf模板引擎编写HTML页面模板引擎使用
    
                    
    • 
                    
  • JavaWeb原生框架开发JSP+Servlet+JDBC案例
                        秦老师Q
JavaWeb基础javaservlet开发语言
                        
    目录概要功能技术名词解释技术细节1.项目列表2.网页3.Servlet小结概要JavaWeb开发案例，使用JSP、Servlet、JDBC原生框架技术，实现用户模块的功能开发，主要用于学习。功能1.注册2.登录3.用户模块3.1查询用户信息3.2删除用户信息3.3修改用户信息技术名词解释JSP：全称JavaServerPages,是由Sun公司主导创建的一种动态网页技术标准，JSP中可以编写Jav
    
                    
    • 
                    
  • EL表达式与JSTL标签库详解
                        秦老师Q
JavaWeb基础java
                        
    前言本章主要学习EL表达式与JSTL标签库，用于简化JSP数据操作。收录JavaWeb基础系列，该系列主要学习JavaWeb开发原生框架、Servlet、JSP、request请求对象、response响应对象、Session会话对象、Filter过滤器、EL表达式、JSTL标签库、三层开发模型等知识点，欢迎童鞋们互相交流。觉得不错可以三连订阅喔。目标一、EL表达式1.概念2.语法3.示例4.EL
    
                    
    • 
                    
  • [转载]Nodejs 利用 express 框架 获取接口参数
                        柒柒公子呐
node.js
                        
    Express是一个基于Node.js平台，快速、开放、极简的web开发框架Expresss是一个第三方模块（在npm上可以下载），在使用它之前要先去下载它，在下载包之前要先创建项目，并通过npminit创建package.json文件。1、get接口参数req.query属性express框架会自动收集get方式从url地址中传递的查询字符串参数，并自动保存在req对象的query属性中。我们直
    
                    
    • 
                    
  • 在electron中实现一个桌面悬浮球
                        

                        
    概要在electron+vue3搭建的应用中实现了一个桌面悬浮球/mini窗口的功能，支持任意拖拽、丝滑的菜单折叠展开动画效果。在实现过程中需要关注的一些点：1、管理悬浮球窗口创建以及配置：需要一个透明的窗口来承载视图。2、解决electron拖拽和点击事件冲突（核心）：因为使用-webkit-app-region:drag样式的方式会导致拖拽和点击事件冲突，所以需要通过渲染进程和主进程的通信来解
    
                    
    • 
                    
  • 如何使用Visual Studio Code调试PHP CLI应用和Web应用
                        

                        
    Python中的class体内定义方法时，如果没有显式地包含self参数，有时候依然可以被调用。这是一个非常有趣的话题，因为它涉及到对Python中类与对象之间关系的更深理解。要理解为什么这种情况下方法依然能够被调用，我们需要逐步拆解Python类的构造方式以及方法绑定的原理。
    
                    
    • 
                    
  • JavaWeb合集17-拦截器（Interceptor）和过滤器（Filter）
                        永恒之月℡
JavaWeb合集1024程序员节javajavaweb过滤器拦截器
                        
    十七、拦截器和过滤器在JavaWeb开发中，拦截器（Interceptor）和过滤器（Filter）都是用于在请求处理前后执行某些操作的机制。虽然它们的功能相似，但在实现方式、使用场景和灵活性方面有一些重要的区别。1、拦截器和过滤器的区别及选择1.1拦截器定义：拦截器是Spring框架提供的一个机制，用于在请求处理前后执行某些操作。它基于AOP（面向切面编程）的思想。作用：通常用于处理与业务逻辑相
    
                    
    • 
                    
  • PouchDB + Dexie.js：构建高效的离线优先同步方案
                        maply
前端Node.jsjavascript开发语言前端dexie.jsPouchDBIndexedDB
                        
    PouchDB+Dexie.js：构建高效的离线优先同步方案在现代Web应用中，离线优先(Offline-First)已成为提升用户体验的关键策略。尤其是在网络环境不稳定的情况下，用户仍然可以访问和操作数据，并在网络恢复后自动同步。PouchDB和Dexie.js是IndexedDB生态中两款强大的库，结合它们可以构建一个高效、可扩展的离线优先同步方案。在这篇文章中，我们将深入探讨：Dexie.j
    
                    
    • 
                    
  • node笔记05——Nodejs学习之Express中间件与接口的编写，GET和POST接口的编写和案例演示。
                        noahsark747
学习中间件前端
                        
    认识expressexpress是基于Node.js平台的web开发框架作用和Node.js内置的http模块类似，是专门用来创建Web服务器的。本质上Express就是一个npm的第三方包提供了快速创建Web服务器的便捷方法。中文官网：expressjs.com.cnexpress的作用：快速方便的创建Web网站服务器和API接口服务器express的基本使用一、下载express包npmiex
    
                    
    • 
                    
  • Nodejs 利用 express 第三方模块 获取接口参数
                        H-萝贝
node.js
                        
    Express是一个基于Node.js平台，快速、开放、极简的web开发框架Expresss是一个第三方模块（在npm上可以下载），在使用它之前要先去下载它，在下载包之前要先创建项目，并通过npminit创建package.json文件。1、get接口参数req.query属性express框架会自动收集get方式从url地址中传递的查询字符串参数，并自动保存在req对象的query属性中。我们直
    
                    
    • 
                    
  • JavaWeb开发 - Filter过滤器详解
                        秦老师Q
JavaWeb基础javawebjava-ee
                        
    前言本章节主要学习JavaWeb开发中的Filter过滤器技术，收录于JavaWeb基础专栏，该专栏主要学习JavaWeb开发原生框架、Servlet、JSP、请求对象、响应对象、Session会话对象、Filter过滤器、三层开发模型等知识点，欢迎童鞋们互相交流。觉得不错可以三连订阅喔。目标1.概念2.Filter介绍3.入门案例4.验证登录案例4.1登录代码4.2过滤器验证内容1.概念Filt
    
                    
    • 
                    
  • JavaWeb 前端基础 html + CSS 快速入门 | 018
                        菜鸟阿康学习编程
前端前端htmlcss
                        
    今日推荐语指望别人的救赎，势必走向毁灭——波伏娃日期学习内容打卡编号2025年01月17日JavaWeb前端基础html+CSS018前言哈喽，我是菜鸟阿康。今天正式进入JavaWeb的学习，简单学习html+CSS这2各前端基础部分，以下是我的重点总结，希望对你有所帮助。（建议先看左侧目录，先了解文章结构）（请忽略错误的大纲编号，我直接从笔记中粘贴过来的，就没严格纠正了，重点在内容！）文末和主页
    
                    
    • 
                    
  • java调用webservice，restful
                        ams77019
javajson
                        
    java调用webservicepublicStringredoEsb(Stringloguid,Stringuser,Stringcomments,StringnewMsg,StringipLocation)throwsException{//StringredoEsb=VariableStore.getValue("redoEsb");StringredoEsb="D:\Admin\"Stri
    
                    
    • 
                    
  • 用Python做一个网页
                        我是学习编程的人 多多照顾我吧求你
python
                        
    要用Python做一个网页，你可以使用Flask或Django这样的Web框架。这里以Flask为例，给出一个简单的示例：1.首先，确保你已经安装了Flask。如果没有，可以使用以下命令安装：```bashpipinstallflask```2.创建一个名为`app.py`的文件，并在其中编写以下代码：```pythonfromflaskimportFlask,render_templateapp
    
                    
    • 
                    
  • 锐捷路由器网关RG-NBR6135-E和锐捷交换机 Ruijie Reyee RG-ES224GC 电脑登录web方法
                        zh7314
硬件工程
                        
    2025年1月17日22:29:35最近淘了点东西，准备在家里搞一套深度学习的服务器，先把网关和交换机搞到了锐捷路由器网关RG-NBR6135-E电脑登录web方法在拿到机器的时候，如果不是全新建议拿根牙签，差入reset5-10秒,灯光会全部闪几下，重置机器，因为有些机器会配置的ip和网段无法访问默认的web服务ip，在机器上面的默认配置单配置参考：https://baijiahao.baidu
    
                    
    • 
                    
  • Go实战全家桶之三十六： go动态创建结构体
                        leijmdas
gogo实战全家桶golang开发语言后端
                        
    开源：water/gowebfunc(self*PagedbRequest)CreateDbTableStru(meta*metadata.MetadataTable)reflect.Value{varmetaColService=service.NewMetadataFactroy()dbFields:=[]reflect.StructField{}for_,col:=rangemeta.Col
    
                    
    • 
                                
  • apache ftpserver-CentOS config
                                    gengzg
apache
                                    
    <server xmlns="http://mina.apache.org/ftpserver/spring/v1"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
       http://mina.apache.o
    
                                
    • 
                                
  • 优化MySQL数据库性能的八种方法
                                    AILIKES
sqlmysql
                                    
    1、选取最适用的字段属性 　　MySQL可以很好的支持大数据量的存取，但是一般说来，数据库中的表越小，在它上面执行的查询也就会越快。因此，在创建表的时候，为了获得更好的 性能，我们可以将表中字段的宽度设得尽可能小。例如，在定义邮政编码这个字段时，如果将其设置为CHAR(255),显然给数据库增加了不必要的空间，甚至使用VARCHAR这种类型也是多余的，因为CHAR(6)就可以很
    
                                
    • 
                                
  • JeeSite 企业信息化快速开发平台
                                    Kai_Ge
JeeSite
                                    
    JeeSite 企业信息化快速开发平台  
平台简介 
JeeSite是基于多个优秀的开源项目，高度整合封装而成的高效，高性能，强安全性的开源Java EE快速开发平台。 
JeeSite本身是以Spring Framework为核心容器，Spring MVC为模型视图控制器，MyBatis为数据访问层， Apache Shiro为权限授权层，Ehcahe对常用数据进行缓存，Activit为工作流
    
                                
    • 
                                
  • 通过Spring Mail Api发送邮件
                                    120153216
邮件main
                                    
    原文地址：http://www.open-open.com/lib/view/open1346857871615.html 
使用Java Mail API来发送邮件也很容易实现，但是最近公司一个同事封装的邮件API实在让我无法接受，于是便打算改用Spring Mail API来发送邮件，顺便记录下这篇文章。 【Spring Mail API】 
Spring Mail API都在org.spri
    
                                
    • 
                                
  • Pysvn 程序员使用指南
                                    2002wmj
SVN
                                    
    源文件:http://ju.outofmemory.cn/entry/35762 
这是一篇关于pysvn模块的指南. 
完整和详细的API请参考 http://pysvn.tigris.org/docs/pysvn_prog_ref.html. 
pysvn是操作Subversion版本控制的Python接口模块. 这个API接口可以管理一个工作副本, 查询档案库, 和同步两个. 
该
    
                                
    • 
                                
  • 在SQLSERVER中查找被阻塞和正在被阻塞的SQL
                                    357029540
SQL Server
                                    
    SELECT  R.session_id AS BlockedSessionID ,  
        S.session_id AS BlockingSessionID ,  
        Q1.text AS Block
    
                                
    • 
                                
  • Intent 常用的用法备忘
                                    7454103
.netandroidGoogleBlogF#
                                    
    Intent 
    应该算是Android中特有的东西。你可以在Intent中指定程序 要执行的动作（比如：view,edit,dial），以及程序执行到该动作时所需要的资料 。都指定好后，只要调用startActivity()，Android系统 会自动寻找最符合你指定要求的应用 程序，并执行该程序。 
 
下面列出几种Intent 的用法 
显示网页: 
 

    
                                
    • 
                                
  • Spring定时器时间配置
                                    adminjun
spring时间配置定时器
                                    
    红圈中的值由6个数字组成，中间用空格分隔。第一个数字表示定时任务执行时间的秒，第二个数字表示分钟，第三个数字表示小时，后面三个数字表示日，月，年，< xmlnamespace prefix ="o" ns ="urn:schemas-microsoft-com:office:office" />  
测试的时候，由于是每天定时执行，所以后面三个数
    
                                
    • 
                                
  • POJ 2421 Constructing Roads 最小生成树
                                    aijuans
最小生成树
                                    
    来源：http://poj.org/problem?id=2421 
题意：还是给你n个点，然后求最小生成树。特殊之处在于有一些点之间已经连上了边。 
思路：对于已经有边的点，特殊标记一下，加边的时候把这些边的权值赋值为0即可。这样就可以既保证这些边一定存在，又保证了所求的结果正确。 
代码： 
 
#include <iostream>
#include <cstdio>
    
                                
    • 
                                
  • 重构笔记——提取方法（Extract Method）
                                    ayaoxinchao
java重构提炼函数局部变量提取方法
                                    
    提取方法（Extract Method）是最常用的重构手法之一。当看到一个方法过长或者方法很难让人理解其意图的时候，这时候就可以用提取方法这种重构手法。 
  
下面是我学习这个重构手法的笔记： 
  
提取方法看起来好像仅仅是将被提取方法中的一段代码，放到目标方法中。其实，当方法足够复杂的时候，提取方法也会变得复杂。当然，如果提取方法这种重构手法无法进行时，就可能需要选择其他
    
                                
    • 
                                
  • 为UILabel添加点击事件
                                    bewithme
UILabel
                                    
        默认情况下UILabel是不支持点击事件的，网上查了查居然没有一个是完整的答案，现在我提供一个完整的代码。 
  
  UILabel *l = [[UILabel alloc] initWithFrame:CGRectMake(60, 0, listV.frame.size.width - 60, listV.frame.size.height)]
    
                                
    • 
                                
  • NoSQL数据库之Redis数据库管理(PHP-REDIS实例)
                                    bijian1013
redis数据库NoSQL
                                    
    一.redis.php 
<?php
      //实例化
      $redis = new Redis();
      //连接服务器
      $redis->connect("localhost");
      //授权
      $redis->auth("lamplijie");
      //相关操
    
                                
    • 
                                
  • SecureCRT使用备注
                                    bingyingao
secureCRT每页行数
                                    
    SecureCRT日志和卷屏行数设置 
 
一、使用securecrt时，设置自动日志记录功能。 
 
1、在C:\Program Files\SecureCRT\下新建一个文件夹(也就是你的CRT可执行文件的路径），命名为Logs； 
 
2、点击Options -> Global Options -> Default Session -> Edite Default Sett
    
                                
    • 
                                
  • 【Scala九】Scala核心三：泛型
                                    bit1129
scala
                                    
    泛型类 
package spark.examples.scala.generics

class GenericClass[K, V](val k: K, val v: V) {
  def print() {
    println(k + "," + v)
  }
}

object GenericClass {
  def main(args: Arr
    
                                
    • 
                                
  • 素数与音乐
                                    bookjovi
素数数学haskell
                                    
        由于一直在看haskell，不可避免的接触到了很多数学知识，其中数论最多，如素数，斐波那契数列等，很多在学生时代无法理解的数学现在似乎也能领悟到那么一点。 
    闲暇之余，从图书馆找了<<The music of primes>>和<<世界数学通史>>读了几遍。其中素数的音乐这本书与软件界熟知的&l
    
                                
    • 
                                
  • Java-Collections Framework学习与总结-IdentityHashMap
                                    BrokenDreams
Collections
                                    
            这篇总结一下java.util.IdentityHashMap。从类名上可以猜到，这个类本质应该还是一个散列表，只是前面有Identity修饰，是一种特殊的HashMap。 
        简单的说，IdentityHashMap和HashM
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-享元模式-Flyweight
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 



import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java
    
                                
    • 
                                
  • PS人像润饰&调色教程集锦
                                    cherishLC
PS
                                    
      1、仿制图章沿轮廓润饰——柔化图像，凸显轮廓 
 
http://www.howzhi.com/course/retouching/ 
  新建一个透明图层，使用仿制图章不断Alt+鼠标左键选点，设置透明度为21%，大小为修饰区域的1/3左右（比如胳膊宽度的1/3），再沿纹理方向（比如胳膊方向）进行修饰。 
  所有修饰完成后，对该润饰图层添加噪声，噪声大小应该和
    
                                
    • 
                                
  • 更新多个字段的UPDATE语句
                                    crabdave
update
                                    
    更新多个字段的UPDATE语句 
  
                 
                update tableA a
                   set (a.v1, a.v2, a.v3, a.v4) =   --使用括号确定更新的字段范围
          
    
                                
    • 
                                
  • hive实例讲解实现in和not in子句
                                    daizj
hivenot inin
                                    
    本文转自：http://www.cnblogs.com/ggjucheng/archive/2013/01/03/2842855.html 
 
 
当前hive不支持 in或not in 中包含查询子句的语法，所以只能通过left join实现。 
 
假设有一个登陆表login(当天登陆记录,只有一个uid),和一个用户注册表regusers(当天注册用户，字段只有一个uid)，这两个表都包含
    
                                
    • 
                                
  • 一道24点的10+种非人类解法（2,3,10,10）
                                    dsjt
算法
                                    
    这是人类算24点的方法？！！！ 
 
事件缘由：今天晚上突然看到一条24点状态，当时惊为天人，这NM叫人啊？以下是那条状态 
 
朱明西 : 24点，算2 3 10 10，我LX炮狗等面对四张牌痛不欲生，结果跑跑同学扫了一眼说，算出来了，2的10次方减10的3次方。。我草这是人类的算24点啊。。 
 
然后么。。。我就在深夜很得瑟的问室友求室友算 
 
刚出完题，文哥的暴走之旅开始了 
 
5秒后
    
                                
    • 
                                
  • 关于YII的菜单插件 CMenu和面包末breadcrumbs路径管理插件的一些使用问题
                                    dcj3sjt126com
yiiframework
                                    
    在使用 YIi的路径管理工具时，发现了一个问题。                    <?php         
    
                                
    • 
                                
  • 对象与关系之间的矛盾：“阻抗失配”效应[转]
                                    come_for_dream
对象
                                    
    概述 
  
“阻抗失配”这一词组通常用来描述面向对象应用向传统的关系数据库（RDBMS）存放数据时所遇到的数据表述不一致问题。C++程序员已经被这个问题困扰了好多年，而现在的Java程序员和其它面向对象开发人员也对这个问题深感头痛。 
  
“阻抗失配”产生的原因是因为对象模型与关系模型之间缺乏固有的亲合力。“阻抗失配”所带来的问题包括：类的层次关系必须绑定为关系模式（将对象
    
                                
    • 
                                
  • 学习编程那点事
                                    gcq511120594
编程互联网
                                    
    一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
    
                                
    • 
                                
  • Reverse Linked List II
                                    hcx2013
list
                                    
    Reverse a linked list from position m to n. Do it in-place and in one-pass. 
For example:Given 1->2->3->4->5->NULL, m = 2 and n = 4, 
return 
    
                                
    • 
                                
  • Spring4.1新特性——页面自动化测试框架Spring MVC Test HtmlUnit简介
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • Hadoop集群工具distcp
                                    liyonghui160com

                                    
      
  
1. 环境描述 
两个集群：rock 和 stone 
rock无kerberos权限认证，stone有要求认证。 
1. 从rock复制到stone，采用hdfs 
Hadoop distcp -i hdfs://rock-nn:8020/user/cxz/input hdfs://stone-nn:8020/user/cxz/运行在rock端，即源端问题：报版本
    
                                
    • 
                                
  • 一个备份MySQL数据库的简单Shell脚本
                                    pda158
mysql脚本
                                    
    　　主脚本（用于备份mysql数据库）：   　　该Shell脚本可以自动备份 
数据库。只要复制粘贴本脚本到文本编辑器中，输入数据库用户名、密码以及数据库名即可。我备份数据库使用的是mysqlump 命令。后面会对每行脚本命令进行说明。   　　 
1. 分别建立目录“backup”和“oldbackup”   　　#mkdir /backup   　　#mkdir /oldbackup   　
    
                                
    • 
                                
  • 300个涵盖IT各方面的免费资源（中）——设计与编码篇
                                    shoothao
IT资源图标库图片库色彩板字体
                                    
     
 A. 免费的设计资源 
 
 
  Freebbble:来自于Dribbble的免费的高质量作品。 
  Dribbble:Dribbble上“免费”的搜索结果——这是巨大的宝藏。 
  Graphic Burger:每个像素点都做得很细的绝佳的设计资源。 
  Pixel Buddha:免费和优质资源的专业社区。 
  Premium Pixels:为那些有创意的人提供免费的素材。 
  
    
                                
    • 
                                
  • thrift总结 - 跨语言服务开发
                                    uule
thrift
                                    
    官网 
官网JAVA例子 
thrift入门介绍 
IBM-Apache Thrift - 可伸缩的跨语言服务开发框架 
Thrift入门及Java实例演示 
thrift的使用介绍 
  
RPC  
  
POM： 
<dependency>
  <groupId>org.apache.thrift</groupId>
  
    
                                
    •