CGS_______

Spring4入门笔记

文章目录

1. 什么是Srping
2. 下载Spring
3. IOC与DI
4. Spring中Bean的相关配置

4.1 bean的生命周期配置：
4.2 bean的作用范围配置：

5. Spring的属性注入
6. Spring的分模块开发

6.1 代码加载xml
6.2 xml文件包含

7. Spring的IOC的注解详解

7.1 @Component：组件
7.2 属性注入的注解

8. Spring的AOP开发

8.1 AOP相关术语
8.2 AOP基于AspectJ的XML开发
8.3 AOP基于AspectJ的注解开发

9. Spring的JDBC模板的使用

9.1 使用默认连接池的示例
9.2 DBCP与C3P0连接池的配置
9.3 引入外部属性文件
9.4 JDBC的CRUD操作

10. Spring的事务管理

10.1 事务的特性
10.2 不考虑隔离性引发的安全问题
10.3 解决读问题
10.4 Spring事务管理的API

10.4.1 PlatformTransactionManager
10.4.2 TransactionDefinition
10.4.3 TransactionStatus
10.4.4 事务管理的API关系

10.5 Spring的事务传播行为
10.6 Spring的事务管理示例

10.6.1 编程式事务管理
10.6.2 声明式事务管理

10.6.2.1 XML方式声明式事务管理
10.6.2.2 注解方式声明式事务管理

1. 什么是Srping

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架.

Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。

目的：解决企业应用开发的复杂性
功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能
范围：任何Java应用

Spring作为SE、EE开发的一站式框架具有以下优点：

IOC方便解耦
AOP对程序进行扩展
轻量级框架
方便与其他框架整合

2. 下载Spring

下载指定版本的Spring（我这里用的4.2.4）：https://repo.spring.io/release/org/springframework/spring/
下载解压后的目录如下：

3. IOC与DI

IOC控制反转将对象的创建权交给了Spring管理，而DI的前提是必须有IOC环境（Spring管理类的时候将类依赖的属性注入）

applicationContext.xml的配置示例：


<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd">
	
	
	<bean id="userDao" name="userDao" class="com.itheima.spring.demo1.UserDaoImpl" init-method="setup" destroy-method="destory">
		<property name="name" value="张三bean">property>
	bean>
	
beans>

代码示例：

package com.itheima.spring.demo1;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.sun.glass.ui.Application;
import org.springframework.context.ApplicationContext;

public class SpringDemo1 {
 @Test
 //传统方式调用
 public void demo1() {
  UserDao userDao = new UserDaoImpl();
  userDao.setName("张三");
  userDao.save();
 }
 
 @Test
 //Spring方式调用
 public void demo2() {
  //ApplicationContext 
  ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
  UserDao userDao = (UserDao)applicationContext.getBean("userDao");
  userDao.save();
  applicationContext.close();
 }
}

4. Spring中Bean的相关配置

bean标签的id和name，其中id使用了唯一约束里面不能出现特殊字符，name没有使用唯一约束里面可以出现特殊字符（例如spring和structs1整合的时候）

4.1 bean的生命周期配置：

init-method ：bean初始化的时候执行的方法
destroy-method ：bean销毁的时候执行的方法（bean是单例创建，工厂关闭时销毁执行）

4.2 bean的作用范围配置：

scope属性

singleton ：默认scope属性配置，单例创建bean
prototype ：多例模式
request ：应用于web项目，spring创建这个类后，将这个类保存到request中
session ：应用于web项目，spring创建这个类后，将这个类保存到session中
globalsession ：应用于web项目，必须在porlet环境下使用

5. Spring的属性注入

支持构造方法方式和set方法方式，但前提是类支持set方法和构造方法


<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
   
   
   
   <bean id="car" class="com.itheima.spring.demo4.Car">
        <constructor-arg name="name" value="大众">constructor-arg>
        <constructor-arg name="price" value="100000">constructor-arg>
   bean>
   
   
   <bean id="car2" class="com.itheima.spring.demo4.Car">
       <property name="name" value="宝马">property>
       <property name="price" value="1000000">property>
   bean>
   <bean id="employee" class="com.itheima.spring.demo4.Employee">
       <property name="name" value="张三">property>
       
       <property name="car" ref="car2">property>
   bean>
   
   
   <bean id="car3" class="com.itheima.spring.demo4.Car" p:name="奇瑞" p:price="1000">
   <bean id="employee1" class="com.itheima.spring.demo4.Employee" p:name="李四" p:car3-ref="car3">
   
   
   <bean id="carInfo" class="com.itheima.spring.demo4.CarInfo">bean>
   <bean id="car4" class="com.itheima.spring.demo4.Car">
       <property name="name" value="#{carInfo.name}">property>
       <property name="price" value="#{carInfo.calculatorPrice()}">property>
   bean>
   <bean id="employee4" class="com.itheima.spring.demo4.Employee">
       <property name="name" value="#{'王五'}">property>
       <property name="car" value="#{car4}">property>
   bean>
   
   
   <bean id="collectionBean" class="com.itheima.spring.demo4.CollectionBean">
     <property name="arrs">
       
       <list>
          <value>aaavalue>
          <value>bbbvalue>
          
       list>
     property>
     <property name="list">
        
        <list>
          <value>cccvalue>
          <value>dddvalue>
          
        list>
     property>
     <property name="set">
       
       <set>
          <value>eeevalue>
          <value>fffvalue>
          
       set>
     property>
     <property name="map">
       
       <map>
          <entry key="ggg" value="111">entry>
          <entry key="hhh" value="222">entry>
       map>
     property>
   bean>

beans>

6. Spring的分模块开发

有两种方式，一种是代码加载xml，另一种是xml文件包含

6.1 代码加载xml

可以在代码中加载多个applicationContext.xml文件，如下：

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml","applicationContext2.xml");

6.2 xml文件包含

也可以使用import将applicationContext2.xml包含到applicationContext.xml中，如下：

<import resource="applicationContext2.xml"/>

7. Spring的IOC的注解详解

@Component(value=“userDao”)//相当于
@PostConstruct//相当于
@Predestroy//相当于注意工厂关闭时才执行

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd"> 
        
        <!-- Spring的IOC的注解入门 -->
        <!-- 使用IOC的注解开发，需要配置组件扫描（哪些包下的类使用IOC注解） -->
        <context:component-scan base-package="com.tiheima.spring.demo1"></context:component-scan>
</beans>

7.1 @Component：组件

修饰一个类，将这个类交给Spring管理
这个注解有三个衍生注解（功能类似）
- @Controller：web层
- @Service：service层
- @Repository：dao层

7.2 属性注入的注解

普通数据：
- @Value：设置普通属性的值
对象类型属性：
- @Autowired：设置对象类型属性的值
  - 一般配合**@Qualifier**一起使用，可以按名称完成属性注入
- @Resource：完成对象类型的属性注入，按照名称完成属性注入

package com.tiheima.spring.demo1;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component(value="userDao")//相当于
public class UserDaoImpl implements UserDao {
    private String name;
    @Value(value="张三啊")//假如没有set方法，则将属性注解加到属性上
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void save() {
        System.out.println("UserDaoImpl中的save()方法执行了..."+name);
    }
}

package com.tiheima.spring.demo1;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service("userService")
public class UserServiceImpl implements UserService {
    //注入DAO
    @Autowired
    @Qualifier(value="userDao")
    private UserDao userDao;

    @Override
    public void save() {
        System.out.println("UserService的save方法执行了");
        userDao.save();
    }
}

8. Spring的AOP开发

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

8.1 AOP相关术语

Joinpoint（连接点）
可以被拦截到的点，称作连接点。如一个类中的方法。
Pointcut（切入点）
真正被拦截到的点，称作切入点。如只对save方法增强，save称作切入点。
Advice（通知、增强）
方法层面的增强。如对save方法进行权限校验，权限校验的方法称为是通知。
Introduction（引介）
类层面的增强。
Target（被增强对象）
例如对UserDao增强，UserDao则称为目标。
Weaving（织入）
将通知应用（Advice）到目标（Target）的过程，将权限校验的方法代码应用到UserDao的 save方法上的过程。
Proxy（代理对象）
Aspect（切面）
多个通知和多个切入点组合。

8.2 AOP基于AspectJ的XML开发

AOP通知类型有：前置、后置、环绕、异常抛出与最终通知。

ProductDaoImpl代码：

package com.itheima.spring.demo3;
public class ProductDaoImpl implements ProductDao {
	@Override
	public void save() {
		System.out.println("save...");
	}
	@Override
	public void update() {
		System.out.println("update...");
	}
	@Override
	public void find() {
		System.out.println("find...");
		int num = 1/0;
	}
	@Override
	public String delete() {
		System.out.println("delete...");
		return "后置通知返回值";
	}
}

MyAspectXML代码：

package com.itheima.spring.demo3;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
public class MyAspectXML {
	public void checkPri(JoinPoint joinPoint) {
		System.out.println("权限校验==========="+joinPoint);
	}
	public void writeLog(Object result) {
		System.out.println("日志记录==========="+result);
	}
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("环绕前通知===========");
		Object obj = joinPoint.proceed();
		System.out.println("环绕后通知===========");
		return obj;
	}
	public void afterThrowing(Throwable ex) {
		System.out.println("异常抛出通知==========="+ex.getMessage());
	}
	public void after() {
		System.out.println("最终通知===========");
	}
}

SpringDemo3代码：

package com.itheima.spring.demo3;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo3 {
	@Resource(name="productDao")
	private ProductDao productDao;
	@Test
	public void demo1() {
		productDao.save();
		productDao.update();
		productDao.find();
		productDao.delete();
	}
}

applicationContext.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<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" xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- bean definitions here -->

	<!-- 配置目标对象：被增强的对象 -->
	<bean id="productDao" class="com.itheima.spring.demo3.ProductDaoImpl"></bean>
	<!-- 将切面类交给Spring管理 -->
	<bean id="myAspect" class="com.itheima.spring.demo3.MyAspectXML"></bean>
	<!-- 通过AOP的配置完成对目标类产生代理 -->
	<aop:config>
		<!-- 表达式配置哪些类的哪些方法需要进行增强 -->
		<aop:pointcut expression="execution(* com.itheima.spring.demo3.ProductDaoImpl.save(..))" id="pointcut1"/>
		<aop:pointcut expression="execution(* com.itheima.spring.demo3.ProductDaoImpl.delete(..))" id="pointcut2"/>
		<aop:pointcut expression="execution(* com.itheima.spring.demo3.ProductDaoImpl.update(..))" id="pointcut3"/>
		<aop:pointcut expression="execution(* com.itheima.spring.demo3.ProductDaoImpl.find(..))" id="pointcut4"/>
		<!-- 配置切面 -->
		<aop:aspect ref="myAspect">
			<!-- 前置通知 -->
			<aop:before method="checkPri" pointcut-ref="pointcut1"/>
			<!-- 后置通知 -->
			<aop:after-returning method="writeLog" pointcut-ref="pointcut2" returning="result"/>
			<!-- 环绕通知 -->
			<aop:around method="around" pointcut-ref="pointcut3"/>
			<!-- 异常抛出通知 -->
			<aop:after-throwing method="afterThrowing" pointcut-ref="pointcut4" throwing="ex"/>
			<!-- 最终通知 -->
			<aop:after method="after" pointcut-ref="pointcut4"/>
		</aop:aspect>
	</aop:config>
</beans>

运行结果：
切入点表达式语法：

基于execution函数
语法
- [访问修饰符] 方法返回值包名.类名.方法名(参数)
- public void com.itheima.spring.CustomerDao.save(…)
- 等等

8.3 AOP基于AspectJ的注解开发

OrderDao代码：

package com.itheima.spring.demo1;
public class OrderDao {
	public void save() {
		System.out.println("保存订单...");
	}
	public void update() {
		System.out.println("修改订单...");
	}
	public String delete() {
		System.out.println("删除订单...");
		return "后置增强返回值";
	}
	public void find() {
		System.out.println("查询订单...");
		int sum = 1 / 0;
	}
}

MyAspectAnno代码：

package com.itheima.spring.demo1;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
/**
 * 切面类：注解的切面类
 * @author cgs
 *
 */
@Aspect
public class MyAspectAnno {
	@Before(value = "execution(* com.itheima.spring.demo1.OrderDao.save(..))")
	public void before() {
		System.out.println("前置增强===========");
	}
	@AfterReturning(value="execution(* com.itheima.spring.demo1.OrderDao.delete(..))",returning="result")
	public void afterReturning(Object result) {
		System.out.println("后置增强==========="+result);
	}
	@Around(value="execution(* com.itheima.spring.demo1.OrderDao.update(..))")
	public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
		System.out.println("环绕前增强===========");
		Object obj = joinPoint.proceed();
		System.out.println("环绕后增强===========");
		return obj;
	}
	@AfterThrowing(value="execution(* com.itheima.spring.demo1.OrderDao.find(..))",throwing="e")
	public void afterThrowing(Throwable e) {
		System.out.println("异常抛出增强==========="+e.getMessage());
	}
	@After(value="MyAspectAnno.pointcut1()")
	public void after() {
		System.out.println("最终增强===========");
	}
	@Pointcut(value="execution(* com.itheima.spring.demo1.OrderDao.find(..))")
	private void pointcut1() {}
}

SpringDemo1代码：

package com.itheima.spring.demo1;
import javax.annotation.Resource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
 * Spring的AOP的注解开发
 * @author cgs
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringDemo1 {
	@Resource(name="orderDao")
	private OrderDao orderDao;
	@Test
	public void demo1() {
		orderDao.save();
		orderDao.update();
		orderDao.delete();
		orderDao.find();
	}
}

applicationContext.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 在配置文件中开启注解的AOP开发 -->
	<aop:aspectj-autoproxy></aop:aspectj-autoproxy>
	<!-- 配置目标类 -->
	<bean id="orderDao" class="com.itheima.spring.demo1.OrderDao" />
	<!-- 配置切面类 -->
	<bean id="myAspect" class="com.itheima.spring.demo1.MyAspectAnno" />
</beans>

运行结果：

9. Spring的JDBC模板的使用

9.1 使用默认连接池的示例

JdbcDemo1代码：

package com.itheima.jdbc.demo1;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 * JDBC模板的使用
 * @author cgs
 */
public class JdbcDemo1 {
	@Test
	// jdbc模板的使用类似于Dbutils
	public void demo1() {
		// 创建连接池
		DriverManagerDataSource dataSource = new DriverManagerDataSource();//spring默认内置连接池
		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql:///spring4_day03");
		dataSource.setUsername("root");
		dataSource.setPassword("p@ssw0rd");
		// 创建模板
		JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
		jdbcTemplate.update("insert into account values(null,?,?)","cgs",10000d);
	}
}

JdbcDemo2代码：

package com.itheima.jdbc.demo1;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcDemo2 {
	@Resource(name="jdbcTemplate")
	private JdbcTemplate jdbcTemplate;
	
	@Test
	public void demo1() {
		jdbcTemplate.update("insert into account values(null,?,?)","cylycgs",20000d);
	}
}

applicationContext.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Spring的内置连接池 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<!-- 属性注入 -->
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///spring4_day03"></property>
		<property name="username" value="root"></property>
		<property name="password" value="p@ssw0rd"></property>
	</bean>
	
	<!-- 配置Spring的JDBC的模板 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
</beans>

9.2 DBCP与C3P0连接池的配置

applicationContext.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Spring的内置连接池 -->
	<!-- <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		属性注入
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///spring4_day03"></property>
		<property name="username" value="root"></property>
		<property name="password" value="p@ssw0rd"></property>
	</bean> -->
	
	<!-- 配置DBCP连接池 -->
	<!-- <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///spring4_day03"></property>
		<property name="username" value="root"></property>
		<property name="password" value="p@ssw0rd"></property>
	</bean> -->
	
	<!-- 配置C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
		<property name="jdbcUrl" value="jdbc:mysql:///spring4_day03"></property>
		<property name="user" value="root"></property>
		<property name="password" value="p@ssw0rd"></property>
	</bean>
	
	<!-- 配置Spring的JDBC的模板 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
</beans>

9.3 引入外部属性文件

jdbc.properties代码：

jdbc.driverClass=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql:///spring4_day03
jdbc.username=root
jdbc.password=p@ssw0rd

applicationContext.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Spring的内置连接池 -->
	<!-- <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		属性注入
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///spring4_day03"></property>
		<property name="username" value="root"></property>
		<property name="password" value="p@ssw0rd"></property>
	</bean> -->
	
	<!-- 配置DBCP连接池 -->
	<!-- <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///spring4_day03"></property>
		<property name="username" value="root"></property>
		<property name="password" value="p@ssw0rd"></property>
	</bean> -->
	
	<!-- 引入属性文件 -->
	<!-- 1.通过bean标签引入 -->
	<!-- <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="location" value="classpath:jdbc.properties"></property>
	</bean> -->
	<!-- 2.通过context标签引入 -->
	<context:property-placeholder location="classpath:jdbc.properties" />
	
	<!-- 配置C3P0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	
	<!-- 配置Spring的JDBC的模板 -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
</beans>

9.4 JDBC的CRUD操作

JdbcDemo2代码：

package com.itheima.jdbc.demo1;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class JdbcDemo2 {
	@Resource(name="jdbcTemplate")
	private JdbcTemplate jdbcTemplate;
	
	@Test
	// 保存操作
	public void demo1() {
		jdbcTemplate.update("insert into account values(null,?,?)","菲菲",10000d);
	}
	@Test
	// 修改操作
	public void demo2() {
		jdbcTemplate.update("update account set money=? where id=?",50000d,1);
	}
	@Test
	// 删除操作
	public void demo3() {
		jdbcTemplate.update("delete from account where id=?",1);
	}
	@Test
	// 查询操作  -- 查询某个字段
	public void demo4() {
		String name = jdbcTemplate.queryForObject("select name from account where id=?",String.class,2 );
	}
	@Test
	// 查询操作  -- 封装到对象中 
	public void demo5() {
		Account account =jdbcTemplate.queryForObject("select * from account where id=?",new MyRowMapper() , 3);
		System.out.println(account);
	}
	@Test
	// 查询操作  -- 封装到对象集合中 
	public void demo6() {
		List<Account> list =jdbcTemplate.query("select * from account",new MyRowMapper());
		for (Account account : list) {
			System.out.println(account);
		}
	}
	
	class MyRowMapper implements RowMapper<Account>{
		@Override
		public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
			Account account = new Account();
			account.setId(rs.getInt("id"));
			account.setName(rs.getString("name"));
			account.setMoney(rs.getDouble("money"));
			return account;
		}
	}
	class Account{
		private Integer id;
		private String name;
		private double money;
		public Integer getId() {
			return id;
		}
		public void setId(Integer id) {
			this.id = id;
		}
		public String getName() {
			return name;
		}
		public void setName(String name) {
			this.name = name;
		}
		public double getMoney() {
			return money;
		}
		public void setMoney(double money) {
			this.money = money;
		}
		@Override
		public String toString() {
			return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
		}
	}
}

10. Spring的事务管理

事务可以理解为逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部失败。

10.1 事务的特性

原子性：事务不可分割
一致性：事务执行前后数据完整性保持一致
隔离性：一个事务的执行不应该受到其他事务的干扰
持久性：一旦事务结束，数据就会持久化到数据库

10.2 不考虑隔离性引发的安全问题

读问题
- 脏读：一个事务读到另一个事务未提交的数据
- 不可重复读：一个事务读到另一个事务已提交的update的数据，导致一个事务中多次查询结果不一致
- 虚读：一个事务读到另一个事务已提交的inser的t数据，导致一个事务中多次查询结果不一致
写问题
- 丢失更新

10.3 解决读问题

设置事务的隔离级别
- read uncommitted：未提交读，任何读问题都解决不了，安全性低，效率高
- read committed：已提交读，解决脏读，但是有可能发生不可重复读和虚读
- repeatable read：重复度，解决脏读和不可重复读，但可能发生虚读
- serialzable：解决所有读问题，安全但效率低

10.4 Spring事务管理的API

10.4.1 PlatformTransactionManager

平台事务管理器：接口，是Spring用于管理事务的真正的对象
- DataSourceTransactionManager：底层使用JDBC事务管理
- HibernateTransactionManager：底层使用Hibernate事务管理

10.4.2 TransactionDefinition

事务定义信息：用于定义事务的相关信息，隔离级别、超时信息、传播行为、是否只读

10.4.3 TransactionStatus

事务状态：用于记录在事务管理过程中，事务的状态的对象

10.4.4 事务管理的API关系

Spring进行事务管理的时候，首先平台事务管理器根据事务定义信息进行事务的管理，在管理过程中产生各种状态，将这些状态的信息记录到事务状态的对象中，这就是API间的关系

10.5 Spring的事务传播行为

Spring中提供了7种事务传播行为：
- 保证多个操作在同一个事务中
  - PROPAGATION_REQUIRED
    默认值，如果A中有事务就会使用A中的事务，如果A中没事务，创建一个新的事务将操作包含进来
  - PROPAGATION_SUPPORTS
    支持事务，如果A中有事务就会使用A中的事务，如果A中没事务，不使用事务
  - PROPAGATION_MANDATORY
    如果A中有事务就会使用A中的事务，如果A中没事务，抛出异常
- 保证多个操作不在同一个事务中
  - PROPAGATION_REQUIRES_NEW
    如果A中有事务，将A的事务挂起（暂停），创建新事务，只包含自身操作。如果A中没事务，创建一个新事务，包含自身操作
  - PROPAGATION_NOT_SUPPORTED
    如果A中有事务，将A的事务挂起（暂停），不使用事务
  - PROPAGATION_NEVER
    如果A中有事务，抛出异常
- 嵌套式事务
  - PTOPAGATION_NESTED
    嵌套事务，如果A中有事务，按照A的事务执行，执行完成后，设置一个保存点，执行B中的操作，如果没有异常，执行通过，如果有异常，可以选择回滚到最初始位置，也可以回滚到保存点

10.6 Spring的事务管理示例

以转账为例，A给B转账需要从A的账户中扣钱，并给B的账户中加钱，这两个步骤，但是如何保证这一组操作是一致性的呢？确保不会出现A的账户扣钱了，但B的账户没有收到的情况，这就需要事务了！

10.6.1 编程式事务管理

AccountService.java代码：

package com.itheima.tx.demo1;
/**
 * 转账的业务层接口
 * @author cgs
 */
public interface AccountService {
	public void transfer(String from,String to,Double money);
}

AccountServiceImpl.java代码：

package com.itheima.tx.demo1;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

/**
 * 转账的业务层实现类
 * @author cgs
 */
public class AccountServiceImpl implements AccountService {
	//注入DAO
	private AccountDao accountDao;
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}
	
	//注入事务管理模板
	private TransactionTemplate transactionTemplate;
	public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
		this.transactionTemplate = transactionTemplate;
	}

	@Override
	/**
	 * from:转出账号
	 * to：转入账号
	 * money：金额
	 */
	public void transfer(final String from,final String to,final Double money) {
		
		transactionTemplate.execute(new TransactionCallbackWithoutResult() {
			@Override
			protected void doInTransactionWithoutResult(TransactionStatus arg0) {
				accountDao.outMoney(from, money);//转出
				int num = 1 / 0;//当使用事务时，遇到异常，A账户的钱不会减少
				accountDao.inMoney(to, money);//转入
			}
		});
	}
}

AccountDao.java代码：

package com.itheima.tx.demo1;
/**
 * 转账的DAO接口
 * @author cgs
 */
public interface AccountDao {
	public void outMoney(String from,Double money);
	public void inMoney(String to,Double money);
}

AccountDaoImpl.java代码：

package com.itheima.tx.demo1;
 
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * 转账的DAO实现类
 * @author cgs
 */
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
	//由于继承了JdbcDaoSupport类，所以tx.xml中直接配置dataSource就可以了，看JdbcDaoSupport源码
	@Override
	public void outMoney(String from, Double money) {
		this.getJdbcTemplate().update("update account set money=money-? where name=?",money,from);
	}

	@Override
	public void inMoney(String to, Double money) {
		this.getJdbcTemplate().update("update account set money=money+? where name=?",money,to);
	}

}

SpringDemo1.java代码：

package com.itheima.tx.demo1;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 测试转账环境
 * @author cgs
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx.xml")
public class SpringDemo1 {
	@Resource(name="accountService")
	private AccountService accountService;
	
	@Test
	public void demo1() {
		//转账，如果没有事务保障，就会出问题，例如转出人已扣钱，被转入人没有收到钱
		accountService.transfer("如花", "菲菲", 1000d);
	}
}

tx.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Service -->
	<bean id="accountService" class="com.itheima.tx.demo1.AccountServiceImpl">
		<property name="accountDao" ref="accountDao"></property>
		<!-- 注入事务管理模板 -->
		<property name="transactionTemplate" ref="transactionTemplate"></property>
	</bean>
	<!-- 配置DAO -->
	<bean id="accountDao" class="com.itheima.tx.demo1.AccountDaoImpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置连接池和JDBC模板 -->
	<!-- 配置C3P0连接池 -->
	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	
	<!-- 配置平台事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 配置事务管理模板 -->
	<bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
		<property name="transactionManager" ref="transactionManager"></property>
	</bean>
</beans>

10.6.2 声明式事务管理

10.6.2.1 XML方式声明式事务管理

AccountDaoImpl.java代码：

package com.itheima.tx.demo2;
 
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * 转账的DAO实现类
 * @author cgs
 */
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
	//由于继承了JdbcDaoSupport类，所以tx.xml中直接配置dataSource就可以了，看JdbcDaoSupport源码
	@Override
	public void outMoney(String from, Double money) {
		this.getJdbcTemplate().update("update account set money=money-? where name=?",money,from);
	}

	@Override
	public void inMoney(String to, Double money) {
		this.getJdbcTemplate().update("update account set money=money+? where name=?",money,to);
	}
}

AccountServiceImpl.java代码：

package com.itheima.tx.demo2;

/**
 * 转账的业务层实现类
 * @author cgs
 */
public class AccountServiceImpl implements AccountService {
	//注入DAO
	private AccountDao accountDao;
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}
	
	@Override
	/**
	 * from:转出账号
	 * to：转入账号
	 * money：金额
	 */
	public void transfer(final String from,final String to,final Double money) {
		accountDao.outMoney(from, money);
		int num = 1 / 0;
		accountDao.inMoney(to, money);
	}
}

SpringDemo1.java代码：

package com.itheima.tx.demo2;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 测试转账环境
 * @author cgs
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx2.xml")
public class SpringDemo1 {
	@Resource(name="accountService")
	private AccountService accountService;
	
	@Test
	public void demo1() {
		//转账，如果没有事务保障，就会出问题，例如转出人已扣钱，被转入人没有收到钱
		accountService.transfer("如花", "菲菲", 1000d);
	}
}

tx2.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Service -->
	<bean id="accountService" class="com.itheima.tx.demo2.AccountServiceImpl">
		<property name="accountDao" ref="accountDao"></property>
	</bean>
	<!-- 配置DAO -->
	<bean id="accountDao" class="com.itheima.tx.demo2.AccountDaoImpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置连接池和JDBC模板 -->
	<!-- 配置C3P0连接池 -->
	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	
	<!-- 配置平台事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 配置事务增强，也就是切面 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="transfer" propagation="REQUIRED" isolation="DEFAULT"/>
			<!-- 事务管理规则示例，此例中没用 -->
			<tx:method name="save*" propagation="REQUIRED"/>
			<tx:method name="update*" propagation="REQUIRED"/>
			<tx:method name="delete*" propagation="REQUIRED"/>
			<tx:method name="find" read-only="true"/>
		</tx:attributes>
	</tx:advice>
	<!-- aop的配置 -->
	<aop:config>
		<aop:pointcut expression="execution(* com.itheima.tx.demo2.AccountServiceImpl.transfer(..))" id="pointcut1"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="pointcut1"/>
	</aop:config>
</beans>

10.6.2.2 注解方式声明式事务管理

AccountDaoImpl.java代码：

package com.itheima.tx.demo3;
 
import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * 转账的DAO实现类
 * @author cgs
 */
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {
	//由于继承了JdbcDaoSupport类，所以tx.xml中直接配置dataSource就可以了，看JdbcDaoSupport源码
	@Override
	public void outMoney(String from, Double money) {
		this.getJdbcTemplate().update("update account set money=money-? where name=?",money,from);
	}

	@Override
	public void inMoney(String to, Double money) {
		this.getJdbcTemplate().update("update account set money=money+? where name=?",money,to);
	}
}

AccountServiceImpl.java代码：

package com.itheima.tx.demo3;

import org.springframework.transaction.annotation.Transactional;

/**
 * 转账的业务层实现类
 * @author cgs
 */
@Transactional
public class AccountServiceImpl implements AccountService {
	//注入DAO
	private AccountDao accountDao;
	public void setAccountDao(AccountDao accountDao) {
		this.accountDao = accountDao;
	}
	
	@Override
	/**
	 * from:转出账号
	 * to：转入账号
	 * money：金额
	 */
	public void transfer(final String from,final String to,final Double money) {
		accountDao.outMoney(from, money);
		int num = 1 / 0;
		accountDao.inMoney(to, money);
	}
}

SpringDemo1.java代码：

package com.itheima.tx.demo3;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 测试转账环境
 * @author cgs
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:tx3.xml")
public class SpringDemo1 {
	@Resource(name="accountService")
	private AccountService accountService;
	
	@Test
	public void demo1() {
		//转账，如果没有事务保障，就会出问题，例如转出人已扣钱，被转入人没有收到钱
		accountService.transfer("如花", "菲菲", 1000d);
	}
}

tx3.xml代码：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop.xsd
	http://www.springframework.org/schema/tx 
	http://www.springframework.org/schema/tx/spring-tx.xsd">
	
	<!-- 配置Service -->
	<bean id="accountService" class="com.itheima.tx.demo3.AccountServiceImpl">
		<property name="accountDao" ref="accountDao"></property>
	</bean>
	<!-- 配置DAO -->
	<bean id="accountDao" class="com.itheima.tx.demo3.AccountDaoImpl">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置连接池和JDBC模板 -->
	<!-- 配置C3P0连接池 -->
	<context:property-placeholder location="classpath:jdbc.properties" />
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
		<property name="driverClass" value="${jdbc.driverClass}"></property>
		<property name="jdbcUrl" value="${jdbc.url}"></property>
		<property name="user" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	
	<!-- 配置平台事务管理器 -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 开启注解事务 -->
	<tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

你可能感兴趣的:(java,java,web)

理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
LocalDateTime 转 String igotyback java 开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类 qt 开发语言 sdl2 linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
Google earth studio 简介陟彼高冈yu 旅游
GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
PHP环境搭建详细教程好看资源平台前端 php
PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计网页设计期末网页作业 html静态网页 html5期末大作业网页设计 web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java 算法华为 javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
git - Webhook让部署自动化大猪大猪
我们现在有一个需求，将项目打包上传到gitlab或者github后，程序能自动部署，不用手动地去服务器中进行项目更新并运行，如何做到？这里我们可以使用gitlab与github的挂钩，挂钩的原理就是，每当我们有请求到gitlab与github服务器时，这时他俩会根据我们配置的挂钩地扯进行访问，webhook挂钩程序会一直监听着某个端口请求，一但收到他们发过来的请求，这时就知道用户有请求提交了，这时
webpack图片等资源的处理 dmengmeng
需要的loaderfile-loader（让我们可以引入这些资源文件）url-loader（其实是file-loader的二次封装）img-loader（处理图片所需要的）在没有使用任何处理图片的loader之前，比如说css中用到了背景图片，那么最后打包会报错的，因为他没办法处理图片。其实你只想能够使用图片的话。只加一个file-loader就可以，打开网页能准确看到图片。{test:/\.(p
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
Java 重写(Override)与重载(Overload) 叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
简单了解 JVM 记得开心一点啊 jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
「豆包Marscode体验官」 | 云端 IDE 启动 & Rust 体验张风捷特烈 ide rust 开发语言后端
theme:cyanosis我正在参加「豆包MarsCode初体验」征文活动MarsCode可以看作一个运行在服务端的远程VSCode开发环境。对于我这种想要学习体验某些语言，但不想在电脑里装环境的人来说非常友好。本文就来介绍一下在MarsCode里，我的体验rust开发体验。一、MarsCode是什么它的本质是:提供代码助手和云端IDE服务的web网站，可通过下面的链接访问https://www
Java企业面试题3 马龙强_ java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Java java
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选 java kafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
python语法——三目运算符 HappyRocking python python 三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
ArrayList 源码解析程序猿进阶 Java基础 ArrayList List java 面试性能优化架构设计 idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
Python神器！WEB自动化测试集成工具 DrissionPage 亚丁号 python 开发语言
一、前言用requests做数据采集面对要登录的网站时，要分析数据包、JS源码，构造复杂的请求，往往还要应付验证码、JS混淆、签名参数等反爬手段，门槛较高。若数据是由JS计算生成的，还须重现计算过程，体验不好，开发效率不高。使用浏览器，可以很大程度上绕过这些坑，但浏览器运行效率不高。因此，这个库设计初衷，是将它们合而为一，能够在不同须要时切换相应模式，并提供一种人性化的使用方法，提高开发和运行效率
Java爬虫框架（一）--架构设计狼图腾-狼之传说 java 框架 java 任务 html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
Java：爬虫框架 dingcho Java java 爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
MongoDB知识概括 GeorgeLin98 持久层 mongodb
MongoDB知识概括MongoDB相关概念单机部署基本常用命令索引-IndexSpirngDataMongoDB集成副本集分片集群安全认证MongoDB相关概念业务应用场景：传统的关系型数据库（如MySQL），在数据操作的“三高”需求以及应对Web2.0的网站需求面前，显得力不从心。解释：“三高”需求：①Highperformance-对数据库高并发读写的需求。②HugeStorage-对海量数
python怎么将png转为tif_png转tif weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）跳房子的前端前端面试 javascript 开发语言 ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
JAVA·一个简单的登录窗口 MortalTom java 开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
TOMCAT在POST方法提交参数丢失问题 357029540 java tomcat jsp
摘自http://my.oschina.net/luckyi/blog/213209 昨天在解决一个BUG时发现一个奇怪的问题，一个AJAX提交数据在之前都是木有问题的，突然提交出错影响其他处理流程。检查时发现页面处理数据较多，起初以为是提交顺序不正确修改后发现不是由此问题引起。于是删除掉一部分数据进行提交，较少数据能够提交成功。恢复较多数据后跟踪提交FORM DATA ，发现数
在MyEclipse中增加JSP模板删除-2008-08-18 ljy325 jsp xml MyEclipse
在D:\Program Files\MyEclipse 6.0\myeclipse\eclipse\plugins\com.genuitec.eclipse.wizards_6.0.1.zmyeclipse601200710\templates\jsp 目录下找到Jsp.vtl，复制一份，重命名为jsp2.vtl,然后把里面的内容修改为自己想要的格式，保存。然后在 D:\Progr
JavaScript常用验证脚本总结 eksliang JavaScript javaScript表单验证
转载请出自出处：http://eksliang.iteye.com/blog/2098985 下面这些验证脚本，是我在这几年开发中的总结，今天把他放出来，也算是一种分享吧，现在在我的项目中也在用！包括日期验证、比较，非空验证、身份证验证、数值验证、Email验证、电话验证等等...! &nb
微软BI（4） 18289753290 微软BI SSIS
1） Q:查看ssis里面某个控件输出的结果： A MessageBox.Show(Dts.Variables["v_lastTimestamp"].Value.ToString()); 这是我们在包里面定义的变量 2):在关联目的端表的时候如果是一对多的关系，一定要选择唯一的那个键作为关联字段。 3) Q：ssis里面如果将多个数据源的数据插入目的端一
定时对大数据量的表进行分表对数据备份酷的飞上天空大数据量
工作中遇到数据库中一个表的数据量比较大，属于日志表。正常情况下是不会有查询操作的，但如果不进行分表数据太多，执行一条简单sql语句要等好几分钟。。分表工具：linux的shell + mysql自身提供的管理命令原理：使用一个和原表数据结构一样的表，替换原表。 linux shell内容如下： =======================开始
本质的描述与因材施教永夜-极光感想随笔
不管碰到什么事,我都下意识的想去探索本质,找寻一个最形象的描述方式。我坚信,世界上对一件事物的描述和解释,肯定有一种最形象,最贴近本质,最容易让人理解 &
很迷茫。。。随便小屋随笔
小弟我今年研一，也是从事的咱们现在最流行的专业（计算机）。本科三流学校，为了能有个更好的跳板，进入了考研大军，非常有幸能进入研究生的行业（具体学校就不说了，怕把学校的名誉给损了）。先说一下自身的条件，本科专业软件工程。主要学习就是软件开发，几乎和计算机没有什么区别。因为学校本身三流，也就是让老师带着学生学点东西，然后让学生毕业就行了。对专业性的东西了解的非常浅。就那学的语言来说
23种设计模式的意图和适用范围 aijuans 设计模式
Factory Method 意图定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。　　适用性当一个类不知道它所必须创建的对象的类的时候。　　当一个类希望由它的子类来指定它所创建的对象的时候。　　当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。 Abstr
Java中的synchronized和volatile aoyouzi java volatile synchronized
说到Java的线程同步问题肯定要说到两个关键字synchronized和volatile。说到这两个关键字，又要说道JVM的内存模型。JVM里内存分为main memory和working memory。 Main memory是所有线程共享的，working memory则是线程的工作内存，它保存有部分main memory变量的拷贝，对这些变量的更新直接发生在working memo
js数组的操作和this关键字百合不是茶 js 数组操作 this关键字
js数组的操作; 一:数组的创建: 1、数组的创建 var array = new Array();　//创建一个数组 var array = new Array([size]);　//创建一个数组并指定长度，注意不是上限，是长度 var arrayObj = new Array([element0[, element1[, ...[, elementN]]]
别人的阿里面试感悟 bijian1013 面试分享工作感悟阿里面试
原文如下：http://greemranqq.iteye.com/blog/2007170 一直做企业系统，虽然也自己一直学习技术，但是感觉还是有所欠缺，准备花几个月的时间，把互联网的东西，以及一些基础更加的深入透析，结果这次比较意外，有点突然，下面分享一下感受吧！ &nb
淘宝的测试框架Itest Bill_chen spring maven 框架单元测试 JUnit
Itest测试框架是TaoBao测试部门开发的一套单元测试框架，以Junit4为核心，集合DbUnit、Unitils等主流测试框架，应该算是比较好用的了。近期项目中用了下，有关itest的具体使用如下： 1.在Maven中引入itest框架： <dependency> <groupId>com.taobao.test</groupId&g
【Java多线程二】多路条件解决生产者消费者问题 bit1129 java多线程
package com.tom; import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.locks.Condition; import java.util.concurrent.loc
汉字转拼音pinyin4j 白糖_ pinyin4j
以前在项目中遇到汉字转拼音的情况，于是在网上找到了pinyin4j这个工具包，非常有用，别的不说了，直接下代码： import java.util.HashSet; import java.util.Set; import net.sourceforge.pinyin4j.PinyinHelper; import net.sourceforge.pinyin
org.hibernate.TransactionException: JDBC begin failed解决方案 bozch ssh 数据库异常 DBCP
org.hibernate.TransactionException: JDBC begin failed: at org.hibernate.transaction.JDBCTransaction.begin(JDBCTransaction.java:68) at org.hibernate.impl.SessionImp
java-并查集（Disjoint-set）-将多个集合合并成没有交集的集合 bylijinnan java
import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.Map; import java.ut
Java PrintWriter打印乱码 chenbowen00 java
一个小程序读写文件，发现PrintWriter输出后文件存在乱码，解决办法主要统一输入输出流编码格式。读文件： BufferedReader 从字符输入流中读取文本，缓冲各个字符，从而提供字符、数组和行的高效读取。可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。通常，Reader 所作的每个读取请求都会导致对基础字符或字节流进行相应的读取请求。因
[天气与气候]极端气候环境 comsci 环境
如果空间环境出现异变...外星文明并未出现,而只是用某种气象武器对地球的气候系统进行攻击,并挑唆地球国家间的战争,经过一段时间的准备...最大限度的削弱地球文明的整体力量,然后再进行入侵...... 那么地球上的国家应该做什么样的防备工作呢? &n
oracle order by与union一起使用的用法 daizj UNION oracle order by
当使用union操作时，排序语句必须放在最后面才正确，如下：只能在union的最后一个子查询中使用order by，而这个order by是针对整个unioning后的结果集的。So：如果unoin的几个子查询列名不同，如 Sql代码 select supplier_id, supplier_name from suppliers UNI
zeus持久层读写分离单元测试 deng520159 单元测试
本文是zeus读写分离单元测试,距离分库分表,只有一步了.上代码: 1.ZeusMasterSlaveTest.java package com.dengliang.zeus.webdemo.test; import java.util.ArrayList; import java.util.List; import org.junit.Assert; import org.j
Yii 截取字符串(UTF-8) 使用组件 dcj3sjt126com yii
1.将Helper.php放进protected\components文件夹下。 2.调用方法： Helper::truncate_utf8_string($content,20,false); //不显示省略号 Helper::truncate_utf8_string($content,20); //显示省略号 &n
安装memcache及php扩展 dcj3sjt126com PHP
安装memcache tar zxvf memcache-2.2.5.tgz cd memcache-2.2.5/ /usr/local/php/bin/phpize (?) ./configure --with-php-confi
JsonObject 处理日期 feifeilinlin521 java json JsonOjbect JsonArray JSONException
写这边文章的初衷就是遇到了json在转换日期格式出现了异常 net.sf.json.JSONException: java.lang.reflect.InvocationTargetException 原因是当你用Map接收数据库返回了java.sql.Date 日期的数据进行json转换出的问题话不多说直接上代码 &n
Ehcache（06）——监听器 234390216 监听器 listener ehcache
监听器 Ehcache中监听器有两种，监听CacheManager的CacheManagerEventListener和监听Cache的CacheEventListener。在Ehcache中，Listener是通过对应的监听器工厂来生产和发生作用的。下面我们将来介绍一下这两种类型的监听器。
activiti 自带设计器中chrome 34版本不能打开bug的解决 jackyrong Activiti
在acitivti modeler中，如果是chrome 34，则不能打开该设计器，其他浏览器可以，经证实为bug，参考 http://forums.activiti.org/content/activiti-modeler-doesnt-work-chrome-v34 修改为，找到 oryx.debug.js 在最头部增加 if (!Document.
微信收货地址共享接口-终极解决 laotu5i0 微信开发
最近要接入微信的收货地址共享接口，总是不成功，折腾了好几天，实在没办法网上搜到的帖子也是骂声一片。我把我碰到并解决问题的过程分享出来，希望能给微信的接口文档起到一个辅助作用，让后面进来的开发者能快速的接入，而不需要像我们一样苦逼的浪费好几天，甚至一周的青春。各种羞辱、谩骂的话就不说了，本人还算文明。如果你能搜到本贴，说明你已经碰到了各种 ed
关于人才 netkiller.github.com 工作面试招聘 netkiller 人才
关于人才每个月我都会接到许多猎头的电话，有些猎头比较专业，但绝大多数在我看来与猎头二字还是有很大差距的。与猎头接触多了，自然也了解了他们的工作，包括操作手法，总体上国内的猎头行业还处在初级阶段。总结就是“盲目推荐，以量取胜”。目前现状许多从事人力资源工作的人，根本不懂得怎么找人才。处在人才找不到企业，企业找不到人才的尴尬处境。企业招聘，通常是需要用人的部门提出招聘条件，由人
搭建 CentOS 6 服务器 - 目录 rensanning centos
(1) 安装CentOS ISO（desktop/minimal）、Cloud（AWS/阿里云）、Virtualization（VMWare、VirtualBox）详细内容 (2) Linux常用命令 cd、ls、rm、chmod...... 详细内容 (3) 初始环境设置用户管理、网络设置、安全设置...... 详细内容 (4) 常驻服务Daemon
【求助】mongoDB无法更新主键 toknowme mongodb
Query query = new Query(); query.addCriteria(new Criteria("_id").is(o.getId())); &n
jquery 页面滚动到底部自动加载插件集合 xp9802 jquery
很多社交网站都使用无限滚动的翻页技术来提高用户体验，当你页面滑到列表底部时候无需点击就自动加载更多的内容。下面为你推荐 10 个 jQuery 的无限滚动的插件： 1. jQuery ScrollPagination jQuery ScrollPagination plugin 是一个 jQuery 实现的支持无限滚动加载数据的插件。 2. jQuery Screw S