原始JDBC操作数据库

传统JDBC方式实现数据库操作

package com.imooc.util;

import java.io.InputStream;
import java.sql.*;
import java.util.Properties; /**
* JDBC工具类:
* 1) 获取Connection
* 2) 释放资源
*/
public class JDBCUtil { /**
* 获取Connection
* @return 所获得到的JDBC的Connection
*/
public static Connection getConnection() throws Exception { /**
* 不建议大家把配置硬编码到代码中
*
* 最佳实践:配置性的建议写到配置文件中
*/
// String url = "jdbc:mysql:///spring_data";
// String user = "root";
// String password = "root";
// String driverClass = "com.mysql.jdbc.Driver"; InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("db.properties");
Properties properties = new Properties();
properties.load(inputStream); String url = properties.getProperty("jdbc.url");
String user = properties.getProperty("jdbc.user");
String password = properties.getProperty("jdbc.password");
String driverClass = properties.getProperty("jdbc.driverClass"); Class.forName(driverClass);
Connection connection = DriverManager.getConnection(url, user, password);
return connection;
} /**
* 释放DB相关的资源
* @param resultSet
* @param statement
* @param connection
*/
public static void release(ResultSet resultSet,
Statement statement, Connection connection){ if(resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
} if(statement != null) {
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
} if(connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
} } }
db.properties

jdbc.url = jdbc:mysql:///spring_data
jdbc.user = root
jdbc.password = root
jdbc.driverClass = com.mysql.jdbc.Driver

接口定义

package com.imooc.dao;

import com.imooc.domain.Student;

import java.util.List;

/**
* StudentDAO访问接口
*/
public interface StudentDAO { /**
* 查询所有学生
* @return 所有学生
*/
public List<Student> query(); /**
* 添加一个学生
* @param student 待添加的学生
*/
public void save(Student student); }
package com.imooc.dao;

import com.imooc.domain.Student;
import com.imooc.util.JDBCUtil; import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List; /**
* StudentDAO访问接口实现类:通过最原始的JDBC的方式操作
*/
public class StudentDAOImpl implements StudentDAO{ @Override
public List<Student> query() { List<Student> students = new ArrayList<Student>(); Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
String sql = "select id, name , age from student";
try {
connection = JDBCUtil.getConnection();
preparedStatement = connection.prepareStatement(sql);
resultSet = preparedStatement.executeQuery(); Student student = null;
while (resultSet.next()) {
int id = resultSet.getInt("id");
String name = resultSet.getString("name");
int age = resultSet.getInt("age"); student = new Student();
student.setId(id);
student.setName(name);
student.setAge(age); students.add(student);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtil.release(resultSet,preparedStatement,connection);
}
return students;
} @Override
public void save(Student student) {
Connection connection = null;
PreparedStatement preparedStatement = null;
ResultSet resultSet = null;
String sql = "insert into student(name, age) values(?,?)";
try {
connection = JDBCUtil.getConnection();
preparedStatement = connection.prepareStatement(sql);
preparedStatement.setString(1, student.getName());
preparedStatement.setInt(2, student.getAge());
preparedStatement.executeUpdate();
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCUtil.release(resultSet,preparedStatement,connection);
}
}
}

JDBC实现操作数据库的测试代码。

package com.imooc.dao;

import com.imooc.domain.Student;
import org.junit.Test; import java.util.List; public class StudentDAOImplTest { @Test
public void testQuery() { StudentDAO studentDAO = new StudentDAOImpl();
List<Student> students = studentDAO.query(); for (Student student : students) {
System.out.println("id:" + student.getId()
+ " , name:" + student.getName()
+ ", age:" + student.getAge());
} } @Test
public void testSave() { StudentDAO studentDAO = new StudentDAOImpl();
Student student = new Student();
student.setName("test");
student.setAge(30); studentDAO.save(student);
} }

使用JdbcTemplate操作数据库

原始JDBC方式操作数据库有很多重复代码,需要自己对数据库连接进行管理。为了简化上述操作可以使用Spring提供的JdbcTemplate操作。

package com.imooc.dao;

import com.imooc.domain.Student;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowCallbackHandler; import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List; /**
* StudentDAO访问接口实现类:通过Spring jdbc的方式操作
*/
public class StudentDAOSpringJdbcImpl implements StudentDAO{ private JdbcTemplate jdbcTemplate; @Override
public List<Student> query() {
final List<Student> students = new ArrayList<Student>();
String sql = "select id, name , age from student"; jdbcTemplate.query(sql, new RowCallbackHandler(){ @Override
public void processRow(ResultSet rs) throws SQLException {
int id = rs.getInt("id");
String name = rs.getString("name");
int age = rs.getInt("age"); Student student = new Student();
student.setId(id);
student.setName(name);
student.setAge(age); students.add(student);
}
}); return students;
} @Override
public void save(Student student) {
String sql = "insert into student(name, age) values(?,?)";
jdbcTemplate.update(sql, new Object[]{student.getName(), student.getAge()});
} public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
} public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
}

需要在Spring配置文件beans.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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
<property name="url" value="jdbc:mysql:///spring_data"/>
</bean> <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"/>
</bean> <bean id="studentDAO" class="com.imooc.dao.StudentDAOSpringJdbcImpl">
<property name="jdbcTemplate" ref="jdbcTemplate"/>
</bean>
</beans>

JdbcTemplate操作数据库的测试代码。

package com.imooc.dao;

import com.imooc.domain.Student;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; import java.util.List; public class StudentDAOSpringJdbcImplTest { private ApplicationContext ctx = null;
private StudentDAO studentDAO = null; @Before
public void setup(){
ctx = new ClassPathXmlApplicationContext("beans.xml");
studentDAO = (StudentDAO)ctx.getBean("studentDAO");
System.out.println("setup");
} @After
public void tearDown(){
ctx = null;
System.out.println("tearDown");
} @Test
public void testQuery() {
List<Student> students = studentDAO.query(); for (Student student : students) {
System.out.println("id:" + student.getId()
+ " , name:" + student.getName()
+ ", age:" + student.getAge());
} } @Test
public void testSave() {
Student student = new Student();
student.setName("test-spring-jdbc");
student.setAge(40); studentDAO.save(student);
} }

虽然Spring JdbcTemplate在一定程度上简化了JDBC操作,但是通过上述代码看到,仍然存在重复代码。

Spring Data

原生JDBC操作与JdbcTemplate操作的弊端

  • 需要书写的代码量还是比较多
  • 有很多的重复代码
  • 如果要开发分页功能或其他功能需要自己进行重新封装

Spring Data JPA

SpringData JPA只是Spring Data中的一个子模块。

JPA是一套标准接口,而Hibernate是JPA的实现。

Spring Data JPA 底层默认实现是使用Hibernate。

Spring DataJPA 的首个接口就是Repository,它是一个标记接口。只要我们的接口实现这个接口,那么我们就相当于在使用SpringDataJPA了。

只要我们实现了这个接口,我们就可以使用"按照方法命名规则"来进行查询。

JPA是用来简化数据库操作的。Spring Data JPA可以支持关系型数据库也支持非关系型数据库。

入门示例

可以使用Spring配置方式或者使用Spring Boot方式。

1、首先介绍Spring Boot的配置方式。

Spring Boot的配置比较简单,直接在Maven的配置文件pom.xml中添加如下依赖。

<dependency
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

此外需要在Spring Boot的配置文件application.properties中配置相应的配置信息。

spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop
spring.jpa.hibernate.ddl-auto=none
spring.jpa.show-sql=true
spring.jackson.serialization.indent_output=true

spring.jpa.properties.hibernate.hbm2ddl.auto是hibernate的配置属性,其主要作用是:自动创建、更新、验证数据库表结构。该参数的几种配置如下:

create:每次加载hibernate时都会删除上一次的生成的表,然后根据你的model类再重新来生成新表,哪怕两次没有任何改变也要这样执行,这就是导致数据库表数据丢失的一个重要原因。

create-drop:每次加载hibernate时根据model类生成表,但是sessionFactory一关闭,表就自动删除。

update:最常用的属性,第一次加载hibernate时根据model类会自动建立起表的结构(前提是先建立好数据库),以后加载hibernate时根据model类自动更新表结构,即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后,表结构是不会被马上建立起来的,是要等应用第一次运行起来后才会。

validate:每次加载hibernate时,验证创建数据库表结构,只会和数据库中的表进行比较,不会创建新表,但是会插入新值。

2、传统Spring方式配置

在Maven的配置文件中添加依赖。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion> <groupId>com.imooc</groupId>
<artifactId>springdata</artifactId>
<version>1.0-SNAPSHOT</version> <dependencies>
<!--MySQL Driver-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.38</version>
</dependency> <!--junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
</dependency> <!--spring-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.3.5.RELEASE</version>
</dependency> <dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.5.RELEASE</version>
</dependency> <!--spring data jpa-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-jpa</artifactId>
<version>1.8.0.RELEASE</version>
</dependency> <dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.3.6.Final</version>
</dependency> </dependencies>
</project>

Spring的配置文件beans.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:tx="http://www.springframework.org/schema/tx"
xmlns:jpa="http://www.springframework.org/schema/data/jpa"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"> <!--1 配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="username" value="root"/>
<property name="password" value="root"/>
<property name="url" value="jdbc:mysql:///spring_data"/>
</bean> <!--2 配置EntityManagerFactory-->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="jpaVendorAdapter">
<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
</property>
<property name="packagesToScan" value="com.imooc"/> <property name="jpaProperties">
<props>
<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.format_sql">true</prop>
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property> </bean> <!--3 配置事务管理器-->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
<property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean> <!--4 配置支持注解的事务-->
<tx:annotation-driven transaction-manager="transactionManager"/> <!--5 配置spring data-->
<jpa:repositories base-package="com.imooc" entity-manager-factory-ref="entityManagerFactory"/> <context:component-scan base-package="com.imooc"/> </beans>

使用JPA

通过上面的两种方式中的任意一种即可使用Spring Data JPA。

1、创建实体

通过ORM框架其会被映射到数据库表中,由于配置了hibernate.hbm2ddl.auto,在应用启动的时候框架会自动去数据库中创建对应的表。

package com.imooc.domain;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id; /**
* 雇员: 先开发实体类===>自动生成数据表
*/
@Entity
public class Employee { private Integer id; private String name; private Integer age; @GeneratedValue
@Id
public Integer getId() {
return id;
} public void setId(Integer id) {
this.id = id;
} @Column(length = 20)
public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public Integer getAge() {
return age;
} public void setAge(Integer age) {
this.age = age;
}
}

2、定义数据访问接口

比如:定义下面这么一个方法,就可以在外界使用了。

Employee findByName(String name);

创建了实体就能够自动帮我们创建数据库表了,修改了实体字段也能够将数据表一起修改。

当然了,上面根据方法名来使用是有弊端的:

1)方法名会比较长: 约定大于配置

2)对于一些复杂的查询,是很难实现

比如:

/ where name like ?% and age <?
public List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age); // where name like %? and age <?
public List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age); // where name in (?,?....) or age <?
public List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age); // where name in (?,?....) and age <?
public List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age);

Repository中查询方法定义规则和使用如下图

因此,对于这种情况下还是要写SQL语句简单得多。可以使用@Query注解使用原生SQL。

package com.imooc.repository;

import com.imooc.domain.Employee;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.RepositoryDefinition;
import org.springframework.data.repository.query.Param; import java.util.List; //如果不继承Repository接口,可以使用注解RepositoryDefinition
@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)
public interface EmployeeRepository { //extends Repository<Employee,Integer>{ //根据命名规则实现查询
public Employee findByName(String name); // where name like ?% and age <?
public List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age); // where name like %? and age <?
public List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age); // where name in (?,?....) or age <?
public List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age); // where name in (?,?....) and age <?
public List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age); //使用Query注解实现查询
@Query("select o from Employee o where id=(select max(id) from Employee t1)")
public Employee getEmployeeByMaxId(); //索引顺序通过 ?+数字 方式表示
@Query("select o from Employee o where o.name=?1 and o.age=?2")
public List<Employee> queryParams1(String name, Integer age); //也可以在查询语句中使用 :+变量名 并在查询方法参数中使用注解 Param 标明查询参数方式实现查询
@Query("select o from Employee o where o.name=:name and o.age=:age")
public List<Employee> queryParams2(@Param("name")String name, @Param("age")Integer age); @Query("select o from Employee o where o.name like %?1%")
public List<Employee> queryLike1(String name); @Query("select o from Employee o where o.name like %:name%")
public List<Employee> queryLike2(@Param("name")String name); //还可以通过设置nativeQuery为true表示使用原生sql查询
@Query(nativeQuery = true, value = "select count(1) from employee")
public long getCount(); //如果要执行更新、删除操作需要额外使用Modifying注解,同时在Service层调用时添加事务 Transational
@Modifying
@Query("update Employee o set o.age = :age where o.id = :id")
public void update(@Param("id")Integer id, @Param("age")Integer age); }

对于修改数据,需要增加Modify注解、并且一定要在事务的管理下才能修改数据。一般事务的管理在Service层实现。

package com.imooc.service;

import com.imooc.repository.EmployeeRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import javax.transaction.Transactional; @Service
public class EmployeeService { @Autowired
private EmployeeRepository employeeRepository; //更新操作需要事务管理,在Service层实现
@Transactional
public void update(Integer id, Integer age) {
employeeRepository.update(id, age);
} }

对数据库的增、删、改都需要配置事务进行处理。事务一般在Service层进行处理。

3、方法调用

经过上面两步即实现了对数据库的基本操作,可以在Controller层调用Service层的服务了。下面通过测试用例模拟Service调用。

package com.imooc.service;

import com.imooc.repository.EmployeeRepository;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext; public class EmployeeServiceTest { private ApplicationContext ctx = null;
private EmployeeService employeeService = null; @Before
public void setup() {
ctx = new ClassPathXmlApplicationContext("beans.xml");
employeeService = ctx.getBean(EmployeeService.class);
System.out.println("setup");
} @After
public void tearDown() {
ctx = null;
System.out.println("tearDown");
} //更新测试用例
@Test
public void testUpdate() {
employeeService.update(1, 55);
} }

Repository的子类

Repository类的定义:

public interface Repository<T, ID extends Serializable> {

}

1)Repository是一个空接口,标记接口

没有包含方法声明的接口

2)如果我们定义的接口EmployeeRepository extends Repository

如果我们自己的接口没有extends Repository,运行时会报错:

org.springframework.beans.factory.NoSuchBeanDefinitionException: No qualifying bean of type 'com.imooc.repository.EmployeeRepository' available

  1. 添加注解能到达到不用extends Repository的功能
@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)

Repository的子类

JpaRepository继承PagingAndSortingRepository,PagingAndSortingRepository又继承CrudRepository,也就是说我们平时自定义的接口只要继承JpaRepository,就相当于拥有了增删查改,分页,等等功能。

JpaSpecificationExecutor提供了查询时的过滤条件。可以通过该接口构造复杂的查询条件。

基本的增删改查和调用存储过程通过Spring Data JPA Repository来解决。

稍微复杂的查询或是批量操作使用QueryDSL或Spring Data Specification的API来解决。

特别特别复杂的查询操作可以使用Spring Data JPA Repository的注解定义native sql来解决。

参考资料:

SpringBoot Data JPA 实战

Spring Boot中使用Spring-data-jpa

SpringData JPA就是这么简单

慕课网 轻松愉快之玩转SpringData

【Spring】Spring Data JPA的更多相关文章

  1. 【Spring】Spring随笔索引

    Spring随笔索引 [Spring]Spring bean的实例化 [Spring]手写Spring MVC [Spring]Spring Data JPA

  2. 【原】Spring整合Redis(第二篇)—SDR环境搭建具体步骤

    [环境参数] Spring版本:4.2.6.RELEASESpring-Data-Redis版本:1.7.2.RELEASE Redis版本:redis-2.4.5-win32-win64 [简要说明 ...

  3. 【转】spring - ioc和aop

    [转]spring - ioc和aop 1.程序中为什么会用到spring的ioc和aop 2.什么是IOC,AOP,以及使用它们的好处,即详细回答了第一个问题 3.原理 关于1: a:我们平常使用对 ...

  4. 【转】Spring总结以及在面试中的一些问题

    [转]Spring总结以及在面试中的一些问题. 1.谈谈你对spring IOC和DI的理解,它们有什么区别? IoC Inverse of Control 反转控制的概念,就是将原本在程序中手动创建 ...

  5. 【转】Spring学习---Spring IoC容器的核心原理

    [原文] Spring的两个核心概念:IoC和AOP的雏形,Spring的历史变迁和如今的生态帝国. IoC和DI的基本概念 IoC(控制反转,英文含义:Inverse of Control)是Spr ...

  6. 【转】Spring中事务与aop的先后顺序问题

    [原文链接] http://my.oschina.net/HuifengWang/blog/304188 [正文] Spring中的事务是通过aop来实现的,当我们自己写aop拦截的时候,会遇到跟sp ...

  7. 【目录】Spring 源码学习

    [目录]Spring 源码学习 jwfy 关注 2018.01.31 19:57* 字数 896 阅读 152评论 0喜欢 9 用来记录自己学习spring源码的一些心得和体会以及相关功能的实现原理, ...

  8. 【DataGuard】部署Data Guard相关参数详解 (转载)

    原文地址:[DataGuard]部署Data Guard相关参数详解 作者:secooler    有关物理Data Guard部署参考<[DataGuard]同一台主机实现物理Data Gua ...

  9. 【机器学习】Iris Data Set(鸢尾花数据集)

    [机器学习]Iris Data Set(鸢尾花数据集) 注:数据是机器学习模型的原材料,当下机器学习的热潮离不开大数据的支撑.在机器学习领域,有大量的公开数据集可以使用,从几百个样本到几十万个样本的数 ...

随机推荐

  1. 谈谈AppDelegate

    谈谈AppDelegate 前言 每个iOS程序都会有一个AppDelegate的类,这个类就是一个代理类,我们新建一个Project的时候,里面都会带有这个类.现在就让我们看看这个类. 开始介绍 对 ...

  2. [转载]PhotoShop性能优化

    现在随着Photoshop版本越来越高功能也越来越强大,而往往强大的功能需要电脑有好的配置运行,比如HDR.图像合成或者3D和视频等类似的功能,还有处理比较大尺寸的图像时,如果电脑配置不够强往往非常卡 ...

  3. jQuery 请指出'$'和'$.fn'的区别?或者说出'$.fn'的用途。

    ---------------------------------------------------------------------------------- 我们先把jQuery看成了一个类, ...

  4. Notes of the scrum meeting(11/1)

    meeting time:9:00~10:30p.m.,November 1st,2013 meeting place:20号公寓楼前 attendees: 顾育豪                   ...

  5. Javascript中bind()方法的使用与实现

    对于bind,我愣了下,这个方法常用在jquery中,用于为被选元素添加一个或多个事件处理程序. 查了下手册,发现bind的作用和apply,call类似都是改变函数的execute context, ...

  6. Top WAF

    http://blog.csdn.net/force_eagle/article/details/9396087

  7. TOMCAT源码分析(转)

    前言:   本文是我阅读了TOMCAT源码后的一些心得. 主要是讲解TOMCAT的系统框架, 以及启动流程.若有错漏之处,敬请批评指教!建议:   毕竟TOMCAT的框架还是比较复杂的, 单是从文字上 ...

  8. echarts map地图设置外边框或者阴影

    geo: { map: 'china', center: [112.194115019531, 23.582111640625], zoom: 12, aspectScale: 1, //长宽比 la ...

  9. uWSGI+APScheduler不能执行定时任务

    在本地项目中使用APScheduler运行定时任务ok,但是在服务器上用uwsgi部署的Django环境下,APScheduler定时任务并不会被启动. 原因:uwsgi 默认one thread o ...

  10. Spring学习二

    Spring的表达式语言 SpEL,使用方法是#{} SpEL的特性如下 使用Bean 的ID 来引用Bean : 调用方法和访问对象的属性: 对值进行算术.关系和逻辑运算: 正则表达式匹配: 集合操 ...