尚硅谷雷丰阳大神的Spring、Spring MVC、MyBatis课程

package com.demo;
 
public class Person {
 
	private String lastName;
	private Integer age;
	private String email;
	private String gender;
 
	@Override
	public String toString() {
		return this.lastName+this.email+this.gender+this.age;
	}
 
	public String getLastName() {
		return lastName;
	}
 
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
 
	public Integer getAge() {
		return age;
	}
 
	public void setAge(Integer age) {
		this.age = age;
	}
 
	public String getEmail() {
		return email;
	}
 
	public void setEmail(String email) {
		this.email = email;
	}
 
	public String getGender() {
		return gender;
	}
 
	public void setGender(String gender) {
		this.gender = gender;
	}
 
}

<?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="person1" class="com.demo.Person">
	  <property name="lastName" value="张三"></property>
	  <property name="age" value="11"></property>
	  <property name="email" value="412198579@qq.com"></property>
	  <property name="gender" value="男"></property>
	</bean>
 
</beans>

package com.demo;
 
import  static org.junit.Assert.*;
 
import org.junit.Test;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class IOCTest {
 
	@Test
	public void test() {
		// 创建 Spring 的 IOC 容器
		// ApplicationContext代表IOC容器
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
		// 从 IOC 容器中获取 bean 的实例
		Person bean = (Person) ioc.getBean("person1");
		System.out.println(bean);
	}
}

Exception in thread "main" java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory
    at org.springframework.jdbc.support.JdbcAccessor.<init>(JdbcAccessor.java:43)
    at org.springframework.jdbc.core.JdbcTemplate.<init>(JdbcTemplate.java:164)
    at DemoJDBCTemplate.Templatedemo1.main(Templatedemo1.java:13)
Caused by: java.lang.ClassNotFoundException: org.apache.commons.logging.LogFactory
    at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:582)
    at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:185)
    at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:496)
    ... 3 more

java.lang.Exception: No tests found matching [{ExactMatcher:fDisplayName=test2], {ExactMatcher:fDisplayName=test2(cn.amumu.spring.test.shiro.ShiroTest12)], {LeadingIdentifierMatcher:fClassName=cn.amumu.spring.test.shiro.ShiroTest12,fLeadingIdentifier=test2]] from org.junit.internal.requests.ClassRequest@33f88ab
at org.junit.internal.requests.FilterRequest.getRunner(FilterRequest.java:37)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.createFilteredTest(JUnit4TestLoader.java:77)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.createTest(JUnit4TestLoader.java:68)
at org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.loadTests(JUnit4TestLoader.java:43)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:444)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.runTests(RemoteTestRunner.java:675)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.run(RemoteTestRunner.java:382)
at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner.main(RemoteTestRunner.java:192)

	public Person(String lastName, Integer age, String email, String gender) {
		this.lastName = lastName;
		this.age = age;
		this.email = email;
		this.gender = gender;
	}

	<bean id="person03" class="com.bean.Person">
		<constructor-arg name="lastName" value="王二麻子"></constructor-arg>
		<constructor-arg name="age" value="11"></constructor-arg>
		<constructor-arg name="email" value="haha@qq.com"></constructor-arg>
		<constructor-arg name="gender" value="男士"></constructor-arg>
	</bean>

	<bean id="person04" class="com.bean.Person"  p:lastName="小小"  p:age="11" p:email="222@qq.com" p:gender="女">
	</bean>

   <bean class="com.bean.Person" name="person01">
     <property name="lastName" value="null">
    </property>
   </bean>
 
    <bean class="com.bean.Person" name="person02">
    <property name="lastName">
    <null></null>
    </property>

	@Test
	public  void test5() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person01",Person.class);
		System.out.println(bean.getLastName() == null);  // 输出false
	}
 
 
 
	@Test
	public  void test6() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person02",Person.class);
		System.out.println(bean.getLastName() == null);   // 输出true
 
	}

	<bean class="com.bean.Person" id="person03">
		<property name="lastName" value="xiaoli"></property>
		<property name="car" ref="car01"></property> //引用外部类
	</bean>
	<bean class="com.bean.Car" id="car01">
		<property name="carName" value="大众汽车"></property>
	</bean>

		public  void test7() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person03",Person.class);
		Car car = bean.getCar();
		car.setCarName("宝马汽车");
		System.out.println(car.getCarName());
	}

	<bean class="com.bean.Person" id="person03">
		<property name="lastName" value="xiaoli"></property>
		<property name="car">
			<bean id="car01" class="com.bean.Car">
				<property name="carName" value="劳斯莱斯汽车"></property>
			</bean>
		</property>
	</bean>

	private List<Book> books;

		<bean class="com.bean.Person" id="person08">
		<property name="lastName" value="xiaoli"></property>
		<property name="books">
		    <list>
		    <bean class="com.bean.Book" id="book001" p:bookName="零基础学jva" p:author="明日科技" ></bean>
		    <bean class="com.bean.Book" id="book002" p:bookName="零基础学PHP" p:author="明日科技" ></bean>
		    <ref bean="book003"></ref>
		    </list>
		</property>
	</bean>
    <bean class="com.bean.Book" id="book003">
      <property name="bookName" value="零基础学C#" ></property>
      <property name="author" value="明日科技"></property>
    </bean>

	public  void test8() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person08",Person.class);
		System.out.println(bean.getBooks());
	}

	private Map<String,Object> maps;
	public Map<String, Object> getMaps() {
		return maps;
	}
	public void setMaps(Map<String, Object> maps) {
		this.maps = maps;
	}

	<bean class="com.bean.Person" id="person08">
		<property name="lastName" value="xiaoli"></property>
		<property name="maps">
		    <map>
		       <entry key="key01" value="喜洋洋"></entry>
		       <entry key="key02" value="灰太狼"></entry>
		       <entry key="key03" value-ref="book003"></entry>
		    </map>
		</property>
	</bean>
 
    <bean class="com.bean.Book" id="book003">
      <property name="bookName" value="零基础学C#" ></property>
      <property name="author" value="明日科技"></property>
    </bean>

		public  void test8() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person08",Person.class);
		System.out.println(bean.getMaps());
	}

	private Properties properties;
	public Properties getProperties() {
		return properties;
	}
	public void setProperties(Properties properties) {
		this.properties = properties;
	}

		<bean class="com.bean.Person" id="person08">
		<property name="properties">
		  <props>
		    <prop key="username">小强</prop>
		    <prop key="age">18</prop>
		  </props>
		</property>
	</bean>

	@Test
	public  void test8() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person08",Person.class);
		System.out.println(bean.getProperties());
	}

    <bean class="com.bean.Person" id="person010">
       		<property name="maps" ref="map01"></property>
    </bean>
    <util:map id="map01">
		       <entry key="key01" value="孙悟空"></entry>
		       <entry key="key02" value="猪八戒灰太狼"></entry>
		       <entry key="key03" value-ref="book003"></entry>
    </util:map>

	@Test
	public  void test10() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person010",Person.class);
		Map maps = (Map<String,Object>)(bean.getMaps());
		System.out.println(maps);
	}

    <bean class="com.bean.Person" id="person011">
       		<property name="car" ref="car01"></property>
       		<property name="car.carName" value="吉利帝豪"></property>
    </bean>
 
    <bean class="com.bean.Car" id="car01">
       		<property name="carName" value="雪佛兰赛欧"></property>
    </bean>

	@Test
	public  void test11() {
		ApplicationContext ioc = new ClassPathXmlApplicationContext("ioc2.xml");
		Person bean =  ioc.getBean("person011",Person.class);
		System.out.println(bean.getCar().getCarName());
	}

	<bean id="person02" class="com.bean.Person">
		<property name="lastName" value="李四"></property>
		<property name="age" value="11"></property>
		<property name="email" value="110@qq.com"></property>
		<property name="gender" value="女"></property>
	</bean> 
	<bean id="person05" class="com.bean.Person" parent="person02">
	  <property name="lastName" value="王二麻子"></property>
	</bean>

	<bean id="person06" class="com.bean.Person" abstract="true">
		<property name="lastName" value="凌凌漆"></property>
		<property name="age" value="11"></property>
		<property name="email" value="110@qq.com"></property>
		<property name="gender" value="女"></property>
	</bean>

	 <bean id=“manager” class=“cn.lovepi.***.CacheManager”depends-on=“sysInit”/>  
     <bean id=“sysInit” class=“cn.lovepi.***.SysInit” />

package com.bean;
public class Plane {
	private String name;
	private String size;
	private String color;
	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return super.toString();
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSize() {
		return size;
	}
	public void setSize(String size) {
		this.size = size;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
}

package com.factory;
import com.bean.Plane;
public class StaticFactory {
   public static Plane makePlane(String method) {
		Plane plane = new Plane();
		plane.setName(method + "工厂造飞机");
		plane.setColor("黑色白色");
		plane.setSize("120米");
		return plane;
   }
}

    <bean class="com.factory.StaticFactory" id="staticFactory" factory-method="makePlane">
        <constructor-arg value="静态工厂"></constructor-arg>
    </bean>

package com.factory;
import com.bean.Plane;
public class ObjectFactory {
	public Plane makePlane(String method) {
		Plane plane = new Plane();
		plane.setName(method + "工厂造飞机");
		plane.setColor("白色");
		plane.setSize("110米");
		return plane;
	}
}

    <bean class="com.factory.ObjectFactory" id="objectFactoryBean" >
    </bean>
    <!-- 
        1.先配置实例工厂对象
        2.配置我们要创建的对象使用哪个对象创建
          ① factory-bean 指定使用哪个工厂实例
          ② factory-method 指定使用哪个工厂方法
     -->
    <bean class="com.bean.Plane" id="objectFactory2" factory-bean="objectFactoryBean" factory-method="makePlane">
       <constructor-arg value="实例工厂"></constructor-arg>
    </bean>

package com.factory;
 
import org.springframework.beans.factory.FactoryBean;
 
import com.bean.Book;
/**
 * 实现FactoryBean的类，Spring会识别为工厂类
 * Spring会自动调用工厂方法创建实例
 */
 
public class FactoryBeanImplements implements FactoryBean<Book>{
 
	@Override
	public Book getObject() throws Exception {
		Book book = new Book();
		book.setAuthor("机械工业出版社");
		book.setBookName("java web从入门到放弃");
		return book;
	}
 
	@Override
	public Class< ?> getObjectType() {
		return Book.class;
	}
 
	@Override
	public boolean isSingleton() {
		return false;
	}
 
}

    <!-- FactoryBean是Spring规定的一个接口
                       只要是实现这个接口的类，Spring都认为是一个工厂
     -->
   <bean class="com.factory.FactoryBeanImplements" id="FactoryBean">
   </bean>

	public void initMethod() {
		System.out.println("init初始化");
	}
 
	public void destroy() {
		System.out.println("销毁");
	}

<bean class="com.bean.Book" id="book01" init-method="initMethod" destroy-method="destroy" scope="singleton"></bean>

	@Test
	public void test() {
		ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
		ioc.close();
	}

<bean class="com.bean.Book" id="book011" init-method="initMethod" destroy-method="destroy" scope="prototype"></bean>

	@Test
	public void test() {
		ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
		Book book = (Book)ioc.getBean("book011");
		ioc.close();   // （容器关闭）不自动销毁Bean
		//book.destroy();   需要手动销毁
	}

package com.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
 
public class BeanPostProcessorDemo implements BeanPostProcessor{
 
	@Override
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("bean初始化之前的方法"+beanName);
		return bean;
	}
 
	@Override
	public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
		System.out.println("bean初始化之后的方法"+beanName);
		return bean;
	}
}

<?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 class="com.bean.Book" id="book011" init-method="initMethod" destroy-method="destroy" scope="prototype"></bean>
   <bean class="com.bean.BeanPostProcessorDemo"></bean>
</beans>

	@Test
	public void test() {
		ConfigurableApplicationContext ioc = new ClassPathXmlApplicationContext("ioc.xml");
		Book book = (Book)ioc.getBean("book011");
		ioc.close();
	}

   <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
     <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/tubu_dangqian"></property>
     <property name="user" value="root"></property>
     <property name="password" value="root"></property>
     <property name="driverClass" value="  "></property>
   </bean>

   	@Test
	public void jdbc() throws SQLException {
		// 1.从容器中拿到连接池
		//DataSource dataSource = (DataSource) ioc.getBean("dataSource");
		// 2.按照类型获取组件，可以获取到这个类型下的所有实现子类等
		DataSource dataSource = ioc.getBean(DataSource.class);
		System.out.println(dataSource.getConnection());
	}

	username=root
	password=root
	jdbcUrl=jdbc:mysql://localhost:3306/tubu_dangqian
	driverClass=com.mysql.jdbc.Driver

   <!-- 加载外部配置文件 固定写法classpath表示引用类路径下的一个资源 -->
   <context:property-placeholder location="classpath:dbconfig.properties"/>
   <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
     <property name="jdbcUrl" value="${jdbcUrl}"></property>
     <property name="user" value="${username}"></property>
     <property name="password" value="${password}"></property>
     <property name="driverClass" value="${driverClass}"></property>
   </bean>

   	public Person(Car car) {
		System.out.println("构造方法");
		this.car = car;
	}

	 <bean id="car" class="com.bean.Car">
	  <property name="carName" value="宝马汽车"></property>
	</bean>
	<bean id ="person07" class="com.bean.Person" autowire="constructor">
	</bean>

		<bean id="person08" class="com.bean.Person">
		  <!-- 引用其他bean的某个属性 -->
		  <property name="lastName" value="#{car.carName}"></property>
		  <!-- 字面量 -->
		  <property name="age" value="#{12*5}"></property>
		  <!-- 引用其他bean -->
		  <property name="car" value="#{car}"></property>
		  <!-- 调用静态方法 #{T(全类名).静态方法 -->
		  <property name="email" value="#{T(java.util.UUID).randomUUID().toString()}@qq.com"></property>
          <!-- 调用静态方法 对象.非静态方法 #{对象.非静态方法}  -->
	      <property name="gender" value="#{car.getCarName()}"></property>
	</bean>

   <!-- context:component-scan 自动组件扫描
        base-package 指定扫描的基础包，把基础包及他下面所有包的所有加了注解的类，自动扫描到ioc容器中
    -->
   <context:component-scan base-package="com.wuxinzhe.service"></context:component-scan>

package com.wuxinzhe.service;
import org.springframework.stereotype.Service;
 
@Service
public class ServiceC {
 
}

	ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");
 
	@org.junit.Test
	public void test() {
		ServiceC bean = (ServiceC)ioc.getBean("serviceC");  // 为类名首字母小写，组件的作用域，默认就是单实例
		System.out.println(bean);
	}

package com.wuxinzhe.dao;
 
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
 
@Repository("daoChangeName")
@Scope(value = "prototype")
public class Dao {
 
}

   <context:component-scan base-package="com.wuxinzhe.dao"></context:component-scan>

   package com.wuxinzhe.test;
import com.wuxinzhe.dao.Dao;
 
import static org.junit.Assert.*;
 
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
public class Test {
	ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");
 
	@org.junit.Test
	public void test() {
		Object bean = ioc.getBean("daoChangeName");
		Object bean2 = ioc.getBean("daoChangeName");
		System.out.println(bean);
		System.out.println(bean2);
	}
}

   <context:component-scan base-package="com.wuxinzhe">
           <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/> 
           <context:exclude-filter type="assignable" expression="com.wuxinzhe.servlet.Servlet"/>    
    </context:component-scan>

         <context:component-scan base-package="com.wuxinzhe" use-default-filters="false">
          <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
      </context:component-scan>

      <context:component-scan base-package="com.wuxinzhe">
      </context:component-scan>

@Controller
public class Servlet {
 
	@Autowired
	private ServiceC service;
 
	public void doGet() {
		System.out.println("servlet.doGet...");
		service.save();
	}
}

@Service
public class ServiceC {
 
	@Autowired
	private Dao dao;
 
	public void save() {
		System.out.print("serviceC.save方法。。。");
		dao.saveData();
	}
}

@Repository("daoChangeName")
@Scope(value = "prototype")
public class Dao {
 
	public void saveData() {
		System.out.println("dao正在保存数据");
	}
}

package com.wuxinzhe.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.wuxinzhe.dao.Dao;
@Service
public class ServiceB {
	@Autowired
	private Dao dao;
 
	public void save() {
		System.out.print("serviceB.save方法。。。");
		dao.saveData();
	}
}

package com.wuxinzhe.service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.wuxinzhe.dao.Dao;
 
@Service
public class ServiceC extends ServiceB{
 
	@Autowired
	private Dao dao;
 
	public void save() {
		System.out.print("serviceC.save方法。。。");
		dao.saveData();
	}
}

package com.wuxinzhe.servlet;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
 
import com.wuxinzhe.service.ServiceB;
 
@Controller
public class Servlet {
 
	@Autowired
	private ServiceB serviceC;
	public void doGet() {
		System.out.println("servlet.doGet...");
		serviceC.save();
	}
}

@Controller
public class Servlet {
	@Qualifier("serviceC")
	@Autowired
	private ServiceB serviceD;
	public void doGet() {
		System.out.println("servlet.doGet...");
		serviceD.save();
	}
}

@Controller
public class Servlet {
	@Qualifier("serviceCCC")
	@Autowired(required=false)
	private ServiceB serviceD;
 
	public void doGet() {
		System.out.println("servlet.doGet..." + serviceD);
		// serviceD.save();
	}
}

	/**方法上有@Autowired的话
	 * 这个方法会在bean创建的时候自动运行
	 * 这个方法上的每一个参数都会自动注入值
	 */
	 @Autowired 
	public void doGet2(@Qualifier("serviceC")ServiceB serviceB,Dao dao) {
		System.out.println("doGet2"+serviceB+dao);
	}

	package com.wuxinzhe.test;
 
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
 
import com.wuxinzhe.dao.Dao;
import com.wuxinzhe.service.ServiceB;
import org.junit.Test;
 
/**
 * 导入 spring-test-4.1.2.RELEASE.jar
 * @ContextConfiguration(locations="")使用它来指定spring配置文件的位置
 * @RunWith指定用哪种驱动进行测试，如果不指定则默认就是Junit
 * 以前的注解是由Junit执行
 */
@ContextConfiguration(locations="classpath:application.xml")
@RunWith(SpringJUnit4ClassRunner.class)
public class IOCTest {
 
	// ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");
	ApplicationContext ioc = null;
 
	@Autowired
	private ServiceB serviceB;
 
	@Autowired
	private Dao dao;
 
 
	@Test
	public void test() {
		System.out.println(serviceB + "" + dao);
	}
}

<context:component-scan base-package="com.wuxinzhe"></context:component-scan>

package com.wuxinzhe.bean;
 
public class User {
 
}

package com.wuxinzhe.bean;
 
public class Book {
 
}

package com.wuxinzhe.dao;
 
public abstract class BaseDao<T> {
	public abstract void save();
}

package com.wuxinzhe.dao;
 
import org.springframework.stereotype.Repository;
 
import com.wuxinzhe.bean.Book;
@Repository
public class BookDao extends BaseDao<Book>{
 
	@Override
	public void save() {
		// TODO Auto-generated method stub
		System.out.println("图书用户Dao正在保存。。。");
	}
 
}

package com.wuxinzhe.dao;
 
import org.springframework.stereotype.Repository;
 
import com.wuxinzhe.bean.User;
@Repository
public class UserDao extends BaseDao<User> {
 
	@Override
	public void save() {
		// TODO Auto-generated method stub
		System.out.println("用户Dao正在保存。。。");
	}
}

package com.wuxinzhe.service;
 
import org.springframework.beans.factory.annotation.Autowired;
 
import com.wuxinzhe.dao.BaseDao;
 
public class BaseService<T> {
	@Autowired
	private BaseDao<T> baseDao;
 
	public void save() {
		System.out.println("自动注入的Dao:" + baseDao);
		baseDao.save();
	}
}

package com.wuxinzhe.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.wuxinzhe.bean.User;
import com.wuxinzhe.dao.UserDao;
 
@Service
public class UserService extends BaseService<User>{
 
}

package com.wuxinzhe.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import com.wuxinzhe.bean.Book;
import com.wuxinzhe.dao.BookDao;
@Service
public class BookService extends BaseService<Book>{
 
}

package com.wuxinzhe.test;
 
import static org.junit.Assert.*;
 
import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import com.wuxinzhe.service.BookService;
import com.wuxinzhe.service.UserService;
 
public class IocTest {
 
	ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");
 
	@Test
	public void test() {
		UserService userService = ioc.getBean(UserService.class);
		BookService bookService = ioc.getBean(BookService.class);
		bookService.save();
		userService.save();
	}
}

System.out.println(bookService.getClass().getGenericSuperclass());

		com.wuxinzhe.service.BaseService<com.wuxinzhe.bean.Book>

package com.wuxinzhe.inter;
 
public interface Calculator {
 
	public int add(int a,int b);
 
	public int minus(int a,int b);
 
	public int multi(int a,int b);
 
	public int div(int a,int b);
}

package com.wuxinzhe.impl;
 
import com.wuxinzhe.inter.Calculator;
 
public class MyCalculator implements Calculator{
 
	@Override
	public int add(int a,int b) {
		int result = a + b;
		return result;
	}
 
 
	@Override
	public int minus(int a, int b) {
		int result = a - b;
		return result;
	}
 
	@Override
	public int multi(int a, int b) {
		int result = a * b;
		return result;
	}
 
	@Override
	public int div(int a, int b) {
		int result = a / b;
		return result;
	}
 
}

package com.wuxinzhe.proxy;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
 
import com.wuxinzhe.impl.MyCalculator;
import com.wuxinzhe.inter.Calculator;
import com.wuxinzhe.log.LogUtils;
 
/**
 * 帮Calculator.java生成代理对象的类 Object newProxyInstance
 */
public class CalculatorProxy {
 
	/**
	 * @param calculator 被代理对象
	 * @return 代理对象
	 */
	public static Calculator getProxy(MyCalculator calculator) {
 
		// 被代理对象的类加载器
		ClassLoader loader = calculator.getClass().getClassLoader();
		// 被代理对象实现的接口
		Class<?>[] interfaces = calculator.getClass().getInterfaces();
		// 方法执行器，帮我们目标对象执行目标方法
		InvocationHandler h = new InvocationHandler() {
			/**
			 * Object proxy 代理对象，给jdk使用，任何时候都不要动这个对象 Method method 当前将要执行目标对象的方法 Object[]
			 * args 这个方法调用时，外界传入的值
			 */
 
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				// 利用反射执行目标方法
				// 目标方法执行后的返回值
				Object result = null;
				try {
					LogUtils.start(method,args);
					result = method.invoke(calculator, args);
				} catch (Exception e) {
					LogUtils.exceptionMsg(e);
				} finally {
				}
				// 返回值必须返回出去，外界才能拿到真正执行后的返回值
				return result;
			}
		};
		// Proxy为目标对象创建代理对象
		Object proxy = Proxy.newProxyInstance(loader, interfaces, h);
		// 返回代理对象
		return (Calculator) proxy;
	}
}

package com.wuxinzhe.log;
 
import java.lang.reflect.Method;
import java.util.Arrays;
 
public class LogUtils {
 
	public static void start(Method method, Object[] args) {
		System.out.println(method.getName() + "方法开始执行");
		System.out.println("参数" + Arrays.asList(args));
	}
 
	public static void exceptionMsg(Exception e) {
		System.out.println(e.getCause());
	}
}

package com.wuxinzhe.test;
 
import static org.junit.Assert.*;
 
import org.junit.Test;
 
import com.wuxinzhe.impl.MyCalculator;
import com.wuxinzhe.inter.Calculator;
import com.wuxinzhe.proxy.CalculatorProxy;
 
public class AopTest {
 
	@Test
	public void test() {
		MyCalculator calculator = new MyCalculator();
		Calculator proxy = CalculatorProxy.getProxy(calculator);
		int result2 = proxy.add(3, 4);
		System.out.println(result2);
	}
 
}

package com.wuxinzhe.impl;
 
import org.springframework.stereotype.Service;
 
import com.wuxinzhe.inter.Calculator;
 
@Service
public class MyCalculator implements Calculator{
 
	@Override
	public int add(int a,int b) {
		int result = a + b;
		return result;
	}
 
	@Override
	public int minus(int a, int b) {
		int result = a - b;
		return result;
	}
 
	@Override
	public int multi(int a, int b) {
		int result = a * b;
		return result;
	}
 
	@Override
	public int div(int a, int b) {
		int result = a / b;
		return result;
	}
 
}

package com.wuxinzhe.log;
 
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class LogUtils {
 
	/**
	 * 告诉Spring每个方法都什么时候运行
	 * 通知注解
	 * @Before：告诉在目标方法之前运行                        前置通知
	 * @After：告诉在目标方法运行结束之后运行                 后置通知
	 * @AfterReturning：在目标方法正常返回之后                返回通知
	 * @AfterThrowing：在目标方法抛出异常之后运行             异常通知
	 * @Around：环绕                                         环绕通知
	 */
 
	// 目标方法执行之前执行
	@Before("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public static void logStart() {
		System.out.println("开始执行");
	}
 
	// 目标方法正常执行完成之后执行
	@AfterReturning("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public static void logEnd() {
		System.out.println("方法有返回值");
	}
 
	// 目标方法出现异常的时候执行
	@AfterThrowing("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public static void exceptionMsg() {
		System.out.println("出现异常的时候");
	}
 
	// 目标方法结束的时候执行
	@After("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public static void logFinally() {
		System.out.println("最终执行方法");
	}
 
}

     <context:component-scan base-package="com.wuxinzhe"></context:component-scan>
 
     <!-- 开启基于注解的AOP功能：aop名称空间 -->
     <aop:aspectj-autoproxy proxy-target-class="true"></aop:aspectj-autoproxy>

package com.wuxinzhe.test;
 
import static org.junit.Assert.*;
 
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.wuxinzhe.inter.Calculator;
 
public class AopTest {
	ApplicationContext ioc = new ClassPathXmlApplicationContext("application.xml");
 
	@Test
	public void test() {
		// 1.从ioc容器中拿到目标对象，注意，如果要用类型，一定用他的接口类型，不要用它本类
		Calculator calculator = ioc.getBean(Calculator.class);
		calculator.div(1,2);
	}
}

     import org.aspectj.lang.JoinPoint;
 
	// 目标方法执行之前执行
	@Before("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public static void logStart(JoinPoint joinPoint) {
		Object[] args = joinPoint.getArgs();
		Signature signature = joinPoint.getSignature();
		String name = signature.getName();
		System.out.println("参数"+Arrays.asList(args));
		System.out.println("signature："+signature);
		System.out.println("signature.getName()："+name);
		System.out.println("开始执行");
	}

	// 目标方法正常执行完成之后执行
	@AfterReturning(value="execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))",returning="result")
	public static void logEnd(JoinPoint joinpoint,Object result) {
		System.out.println("返回值"+result);
	}

	// 目标方法出现异常的时候执行
	@AfterThrowing(value="execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))",throwing="exception")
	public static void exceptionMsg(JoinPoint joinpoint,Exception exception) {
		Signature signature = joinpoint.getSignature();
		String name = signature.getName();
		System.out.println(name+"方法出现异常");
		System.out.println(exception.getMessage());
	}

	/**抽取可重用的切入点表达式
	 * 1.随便声明一个没有实现的返回void的方法
	 * 2.给方法上标注一个@Pointcut注解
	 */
	@Pointcut("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public void getFun() {};

	@Before(value = "getFun()")
	public static void logStart(JoinPoint joinPoint) {
		System.out.println("开始执行");
	}

package com.wuxinzhe.log;
 
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
 
@Aspect
@Component
public class LogUtils2 {
 
	@Pointcut("execution(public int com.wuxinzhe.impl.MyCalculator.*(int , int ))")
	public void getFun() {};
 
	/**
	 * @throws Throwable 
	 * @Around
	 * 环绕通知是Spring中强大的通知
	 * 动态代理
	 * try{
	 *   //前置通知
	 *   method.invoke();
	 *   //返回通知
	 * }catch(e){
	 *   //异常通知
	 * }finally{
	 *   //后置通知
	 * }
	 *  四合一通知就是环绕通知
	 */
 
	@Around(value = "getFun()")
	public Object myAround(ProceedingJoinPoint pjp) throws Throwable {
 
		Object[] args = pjp.getArgs();
		// 利用反射调用目标方法 ,等同于method.invoke(obj.arg);
		Object proceed = null;
		try {
			System.out.println("方法执行之前");
			proceed = pjp.proceed(args);
			System.out.println("方法执行结束");
		} catch (Exception e) {
			System.out.println("触发异常");
		}finally {
			System.out.println("最终执行");
		}
 
		System.out.println("调用反射后的返回值"+proceed);
		// 反射调用后的返回值
		return proceed;
	}
}

	@Test
	public void test() {
		// 1.从ioc容器中拿到目标对象，注意，如果要用类型，一定用他的接口类型，不要用它本类
		Calculator calculator = ioc.getBean(Calculator.class);
		calculator.add(1,2);
		//calculator.div(2,0);
	}

<?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"
	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/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
 
   <bean class="com.wuxinzhe.log.LogUtils3" id="log"></bean>
   <bean class="com.wuxinzhe.impl.MyCalculator" id="myCalculator"></bean>
   <aop:config>
       <aop:pointcut expression="execution(* com.wuxinzhe.impl.*.*(..))" id="globalPoint"/>
	   <aop:aspect ref="log">
	        <aop:pointcut expression="execution(* com.wuxinzhe.impl.*.*(..))" id="onePoint"/>
			<aop:before method="logStart" pointcut-ref="onePoint"/>
			<aop:after-returning method="logEnd" pointcut="execution(* com.wuxinzhe.impl.*.*(..))" returning="result"/>
			<aop:after method="logFinally" pointcut="execution(* com.wuxinzhe.impl.*.*(..))"/>
			<aop:after-throwing method="exceptionMsg" pointcut="execution(* com.wuxinzhe.impl.*.*(..))" throwing="exception"/>
	        <aop:around method="myAround" pointcut-ref="globalPoint"/>
	   </aop:aspect>
   </aop:config>
</beans>

    <context:property-placeholder location="classpath:dbconfig.properties" />
	<bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
		<property name="user" value="${jdbc.user}"></property>
		<property name="password" value="${jdbc.password}"></property>
		<property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>
		<property name="driverClass" value="${jdbc.driverClass}"></property>
	</bean>
 
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
	   <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
	</bean>

	ApplicationContext ioc = new ClassPathXmlApplicationContext("applicationContext.xml");
	JdbcTemplate jdbcTemplate = ioc.getBean(JdbcTemplate.class);

	String sql = "UPDATE test1 SET name = ? WHERE id = ?";
	int a = jdbcTemplate.update(sql, "小明",18);

	String sql = "insert into test1(name,age,sex,content) VALUES(?,?,?,?)";
	List<Object[]> object = new ArrayList<Object[]>();
	object.add(new Object[] { "小明", 11, "男", "帅帅哒" });
	object.add(new Object[] { "小莉莉", 22, "女", "萌萌哒" });
	int[] result = jdbcTemplate.batchUpdate(sql, object);
	for (int i : result) {
		System.out.println(i);
	}

	/**查询时，javaBean需要和数据库中字段名保持一致，否则无法完成封装
	 * 查询集合jdbcTemplate.query()
	 * 查询单个对象jdbcTemplate.queryForObject()，如果查询结果为空，则会抛出报错，则用try..catch捕获异常避免错误发生
	 */
	@Test
	public void test4() {
		String sql = "SELECT id,name,age,sex,content FROM test1 WHERE id = ?";
		User user = null;
		try {
			// RowMapper 每一行记录和JavaBean的属性如何映射
			user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), 29000);
		} catch (DataAccessException e) {
			// TODO Auto-generated catch block
		}
	    System.out.println(user);
	    System.out.println(user.getId());
	}

		String sql = "SELECT id,name,age,sex,content FROM test1 WHERE id > ?";
		List<User> users = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class), 1);
		// System.out.println(users);
		for (User user : users) {
			System.out.println(user.getName());
		}

	String sql = "SELECT MAX(id) FROM test1";
	//System.out.println(jdbcTemplate.queryForInt(sql));
	System.out.println(jdbcTemplate.queryForObject(sql, Integer.class));

	<bean id="namedParameterJdbcTemplate" class="org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate">
	    <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
	</bean>

	String sql = "insert into test1(name,age,sex,content) VALUES(:name,:age,:sex,:content)";
	NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
	Map<String,Object> paramMap = new HashMap<>();
	paramMap.put("name","佟丽娅");
	paramMap.put("age",33);
	paramMap.put("sex","女");
	paramMap.put("content","我的女神哦~");
	int res = namedParameterJdbcTemplate.update(sql, paramMap);
	System.out.println(res);

    NamedParameterJdbcTemplate namedParameterJdbcTemplate = ioc.getBean(NamedParameterJdbcTemplate.class);
	String sql = "insert into test1(name,age,sex,content) VALUES(:name,:age,:sex,:content)";
	User user = new User();
	user.setName("佟丽娅");
	user.setAge(33);
	user.setSex("女");
	user.setContent("我的女神哦~~");
	int res = namedParameterJdbcTemplate.update(sql, new BeanPropertySqlParameterSource(user));
	System.out.println(res);

	package com.wuxinzhe.dao;
 
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.jdbc.core.JdbcTemplate;
	import org.springframework.stereotype.Repository;
 
	import com.wuxinzhe.test.User;
 
	@Repository
	public class UserDao {
 
		@Autowired
		JdbcTemplate jdbcTemplate;
 
		public  void  save(User user) {
			String sql = "insert into test1(name,age,sex,content) VALUES(?,?,?,?)";
			jdbcTemplate.update(sql, user.getName(),user.getAge(),user.getSex(),user.getContent());
		}
 
	}

	<context:component-scan base-package="com.wuxinzhe.dao"></context:component-scan>

	@Test
	public void test9() {
		UserDao userDao = ioc.getBean(UserDao.class);
		User user = new User();
		user.setName("张XX");
		user.setAge(40);
		user.setSex("男");
		user.setContent("风一样的男人");
		userDao.save(user);
	}

	<!-- 事务控制 -->
    <!-- 1：配置事务管理器（切面）让其进行事务控制，一定导入切面的几个包 -->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource"></property>
    </bean>
 
    <!-- 2：开启基于注解的事务控制模式，依赖tx名称空间-->
    <tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

    <!-- 3：给事务方法加注解 -->
	package com.wuxinzhe.service;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.stereotype.Service;
	import org.springframework.transaction.annotation.Transactional;
	import com.wuxinzhe.dao.BookDao;
	@Service 
	public class BookService {
 
		@Autowired
		BookDao bookDao;
 
		@Transactional
		public void checkOrder(String userName,String isbn) {
			int bookPrice  = bookDao.getBookPrice(isbn);
			bookDao.updateUserBalance(userName, bookPrice);
 
			bookDao.updateBookStock(isbn);
		}
	}

	 /**事务的几个属性
	 * 
	 * 异常分类：
	 *   运行时异常：发生异常时,默认回滚
	 *   编译异常：通过try...catch或者throw处理异常 发生异常时，默认不回滚
	 * 
	 * noRollbackFor = class[] 类   指定那些异常不回滚，可以指定默认运行时异常，某些异常可以不用回滚（如ArithmeticException）
	 * noRollbackForClassName = String[] 全类名
	 * 
	 * rollbackFor = class[] 类  指定编译时异常不回滚，但是让某些编译时异常可以回滚（如FileNotFoundException）
	 * rollbackForClassName = String[]
	 * 
	 * timeout:int超时时间
	 * readOnly:boolean事务是否为只读事务，可以进行事务优化，不用管事务那一堆了，但是在有增删改的不可以
	 */
 
	@Transactional(timeout = 3,readOnly = false,noRollbackFor = {ArithmeticException.class},rollbackFor = {FileNotFoundException.class})
	public void checkOrder(String userName,String isbn)  {
 
		int bookPrice  = bookDao.getBookPrice(isbn);
		bookDao.updateUserBalance(userName, bookPrice);
		/**
		try {
			Thread.sleep(3000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		**/
		bookDao.updateBookStock(isbn);
 
	    //int res = 10/0;
		//new FileInputStream("D://HAHAHHAA");
 
	}

	@Transactional
	public void myltiTx() {
 
		bookService.checkOrder("Tom", "ISBN-001");
		bookService.updateBookPrice("ISBN-002", 900);
 
	}

	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public void checkOrder(String userName,String isbn)  {
 
		int bookPrice  = bookDao.getBookPrice(isbn);
		bookDao.updateUserBalance(userName, bookPrice);
 
		bookDao.updateBookStock(isbn);
 
	}
 
 
	@Transactional(propagation  = Propagation.REQUIRED)
	public void updateBookPrice(String isbn,Integer price) {
 
		bookDao.updateBookPrice(isbn, price);
		int res = 10/0;
	}

	MultiService multiService = ioc.getBean(MultiService.class);
	multiService.myltiTx();

	@Transactional(propagation = Propagation.REQUIRES_NEW)
	public void checkOrder(String userName,String isbn)  {
 
		int bookPrice  = bookDao.getBookPrice(isbn);
		bookDao.updateUserBalance(userName, bookPrice);
 
		bookDao.updateBookStock(isbn);
 
		int res = 10/0;
 
	}
 
	@Transactional(propagation  = Propagation.REQUIRED)
	public void updateBookPrice(String isbn,Integer price) {
 
		bookDao.updateBookPrice(isbn, price);
 
	}

	<?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: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/context http://www.springframework.org/schema/context/spring-context-4.1.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.1.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
 
    <context:property-placeholder location="dbconfig.properties"/>
 
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <property name="user" value="${jdbc.user}"></property>
        <property name="password" value="${jdbc.password}"></property>
        <property name="jdbcUrl"  value="${jdbc.jdbcUrl}"></property>
        <property name="driverClass"  value="${jdbc.driverClass}"></property>
    </bean>
 
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
       <constructor-arg name="dataSource" ref="dataSource"></constructor-arg>
    </bean>
 
    <context:component-scan base-package="com.wuxinzhe"></context:component-scan>
 
    <!-- 1：配置事务管理器（切面）让其进行事务控制，一定导入切面的几个包 -->
    <bean id="dataSourceTransactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
      <property name="dataSource" ref="dataSource"></property>
    </bean>
 
    <!-- 事务控制 -->
    <aop:config>
       <aop:pointcut expression="execution(* com.wuxinzhe.service.*.*(..))" id="txPoint"/>
       <!-- 事务建议：事务增强 advice-ref指向事务管理器的配置 -->
       <aop:advisor advice-ref="myAdvice" pointcut-ref="txPoint"/>
    </aop:config>
 
    <tx:advice id="myAdvice" transaction-manager="dataSourceTransactionManager">
        <tx:attributes>
          <tx:method name="*"/>
        </tx:attributes>
    </tx:advice>
 
</beans>

	<servlet>
		<servlet-name>springDispatcherServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<!--springmvc.xml配置文件-->
			<param-value>classpath:springmvc.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
 
	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
		<servlet-name>springDispatcherServlet</servlet-name>
		<!-- 
		/和/*都可以拦截请求
		/会拦截所有请求，但是不会拦截*.jsp请求，能保证jsp访问正常
		/*的范围更大，还会拦截到*.jsp请求，一旦拦截jsp页面就不能正常访问了
		 -->
		<url-pattern>/</url-pattern>
	</servlet-mapping>

	<?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"
		xmlns:context="http://www.springframework.org/schema/context"
		xmlns:p="http://www.springframework.org/schema/p"
		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-4.1.xsd
			http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.1.xsd">
		<context:component-scan base-package="com.wuxinzhe"></context:component-scan>
 
		<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		  <property name="prefix" value="/WEB-INF/pages/"></property>
		  <property name="suffix" value=".jsp"></property>
		</bean>
	</beans>

	package com.wuxinzhe.controller;
 
	import org.springframework.stereotype.Controller;
	import org.springframework.web.bind.annotation.RequestMapping;
 
	@Controller
	public class FirstController {
 
		@RequestMapping("/hello")
		public String helloWorld() {
 
		   System.out.println("请求处理成功");
		   //return "/WEB-INF/pages/success.jsp"; 同下边配置
 
			/*
			 * <bean
			 * class="org.springframework.web.servlet.view.InternalResourceViewResolver">
			 * <property name="prefix" value="/WEB-INF/pages/"></property> <property
			 * name="suffix" value=".jsp"></property> </bean>
			 */
		   return "success";
		}
	}

	<form method="post" action="book/1">
		<input name="_method" value="delete" /> 
		<input type="submit" value="删除图书" />
	</form>
 
	<form method="post" action="book/1">
		<input name="_method" value="put" /> 
		<input type="submit" value="更新图书" />
	</form>

  <!-- The front controller of this Spring Web application, responsible for handling all application requests -->
	<servlet>
		<servlet-name>springmvc</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>springmvc-servlet.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
 
	<!-- Map all requests to the DispatcherServlet for handling -->
	<servlet-mapping>
	    <!--对应WebContent/springmvc-servlet.xml文件-->
		<servlet-name>springmvc</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>
 
	<filter>
	    <filter-name>HiddenHttpMethodFilter</filter-name>
	    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
	</filter>
 
	<filter-mapping>
		<filter-name>HiddenHttpMethodFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	@RequestMapping(value="book/{id}",method = RequestMethod.GET)
	public String getBook(@PathVariable("id") Integer id) {
		System.out.println("您获取了id为"+id+"的图书");
		return "success";
	}
 
 
	@RequestMapping(value="book",method = RequestMethod.POST)
	public String addBook() {
		System.out.println("添加图书成功");
		return "success";
	}
 
	@RequestMapping(value="book/{id}",method = RequestMethod.PUT)
	public String updateBook(@PathVariable("id") Integer id) {
		System.out.println("更新图书" + id + "成功");
		return "success";
	}
 
	@RequestMapping(value="book/{id}",method = RequestMethod.DELETE)
	public String deleteBook(@PathVariable("id") Integer id) {
		System.out.println("删除图书" + id + "成功");
		return "success";
	}

	<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8" isErrorPage="true"%>
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="UTF-8">
	<title>Insert title here</title>
	</head>
		<body>
		恭喜您，请求成功~~
		</body>
	</html>

	@RequestMapping(value="test1")
	public String test1(Integer id) {
		System.out.println("获取的参数值为" + id);
		return "success";
	}

	@RequestMapping(value="test1")
	public String test1(@RequestParam("id") String id) {
		System.out.println("获取的参数值为" + id);
		return "success";
	}

	@RequestMapping(value="test1")
	public String test1(@RequestParam(value="id",required = false)String id) {
		System.out.println("获取的参数值为" + id);
		return "success";
	}

	@RequestMapping(value="test1")
	public String test1(@RequestParam(value="id",defaultValue = "defaultValue") String id) {
		System.out.println("获取的参数值为" + id);
		return "success";
	}

	@RequestMapping(value="test1")
	public String test1(@RequestHeader("Accept") String accept) {
		System.out.println(accept);
		return "success";
	}

	@RequestMapping(value = "cookie")
	public String test2(@CookieValue(value = "JSESSIONID", required = false) String jessId) {
 
		System.out.println("cookie获取成功,参数值为" + jessId);
 
		return "success";
	}

	com.wuxinzhe.dao
	package com.wuxinzhe.dao;
 
public class User {
 
	private String userName;
	private Integer age;
	private Address address;
 
    // 无参构造器
 
	public String getUserName() {
		return userName;
	}
	public void setUserName(String userName) {
		this.userName = userName;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}
	public Address getAddress() {
		return address;
	}
	public void setAddress(Address address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "User [userName=" + userName + ", age=" + age + ", address=" + address + "]";
	}
 
}

package com.wuxinzhe.dao;
 
public class Address {
 
	private String province;
	private String city;
	private String area;
	public String getProvince() {
		return province;
	}
	public void setProvince(String province) {
		this.province = province;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getArea() {
		return area;
	}
	public void setArea(String area) {
		this.area = area;
	}
 
	  @Override 
	public String toString() {
		return "Address [province=" + province + ", city=" + city + ", area=" + area + "]";
	}
}

	<form method="post" action="user">
 
	  用户名：<input type="text" name="userName"/>
 
	  年龄：<input type="text" name="age"/>
 
	  省：<input type="text" name="address.province"/>
 
	 市：<input type="text" name="address.city"/>
 
	 县：<input type="text" name="address.area"/>
 
	  <input type="submit"/>
 
	</form>
	<pre lang="java"  escaped="true">
	处理表单
	<pre lang="java"  escaped="true">
	@RequestMapping(value="user",method=RequestMethod.POST)
	public String userAdd(User user) {
		System.out.println("用户详细信息" + user);
		return "success";
	}

	用户详细信息User [userName=??????, age=11, address=Address [province=?±±???, city=??????, area=????±±]]

	<Connector URIencoding="UTF-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443" />

	<filter>
	  <filter-name>CharacterEncodingFilter</filter-name>
	  <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
	   <init-param>
	      <param-name>encoding</param-name>
	      <param-value>utf-8</param-value>
	   </init-param>
	   	<init-param>
	   		<param-name>forceEncoding</param-name>
	        <param-value>true</param-value>
	   </init-param>
	</filter>
 
	<filter-mapping>
		<filter-name>CharacterEncodingFilter</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

	@RequestMapping("handle01")
	public String handle01(Map<String,Object> map) {
 
		map.put("userName", "佟丽娅");
 
		return "output";
	}

	pageContext:${pageScope.userName}
	session:${ sessionScope.userName } 
	request:${ requestScope.userName}  可以输出
	application:${applicationScope.userName}

	@RequestMapping("handle02")
	public String handle02(Model model) {
 
		model.addAttribute("userName", "佟丽娅");
 
		return "output";
	}

	pageContext:${pageScope.userName}
	session:${ sessionScope.userName } 
	request:${ requestScope.userName}  可以输出
	application:${applicationScope.userName}

	@RequestMapping("handle03")
	public String handle03(ModelMap modelMap) {
 
		modelMap.addAttribute("userName", "佟丽娅");
 
		return "output";
	}

	pageContext:${pageScope.userName}
	session:${ sessionScope.userName } 
	request:${ requestScope.userName}  可以输出
	application:${applicationScope.userName}

	@RequestMapping("handle04")
	public ModelAndView handle04() {
		ModelAndView mv = new ModelAndView("output");
		mv.addObject("userName", "佟丽娅");
		return mv;
	}

	pageContext:${pageScope.userName}
	session:${ sessionScope.userName } 
	request:${ requestScope.userName}  可以输出
	application:${applicationScope.userName}

	@SessionAttributes
	@SessionAttributes(value= {"msg","userName"},types= {String.class})
	@Controller
	public class OutController {
 
		@RequestMapping("handle01")
		public String handle01(Map<String, Object> map) {
 
			map.put("userName", "佟丽娅");
 
			return "output";
		}
 
	}

	@RequestMapping("handle05")
	public String handle05(){
		//return "forward:/forward.jsp";  // 跳转到根目录下WebContent的forward.js页面
		return "forward:/handle04";  
	}

	@RequestMapping("handle06")
	public String handle06(){
		return "redirect:handle05";  
	}

	<!-- 发送一个请求直接来到WEB-INF下的页面
      path指定哪个请求 view-name指定映射哪个视图，需要开启mvc注解模式 -->
    <mvc:view-controller path="/haha" view-name="haha"/>
    <mvc:annotation-driven></mvc:annotation-driven>

	@RequestMapping(value = "userAdd")
	public String userAdd(Model model) {
		model.addAttribute("depts", department.getDepartments());
		//model.addAttribute("employee", new Employee(1001, "张三", "111@qq.com", 1, new Department(104, "D-DD")));
		model.addAttribute("employee", new Employee());
		return "userAdd";
	}

	<%@ page language="java" contentType="text/html; charset=UTF-8"
		pageEncoding="UTF-8"%>
	 <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>   
	 <%@taglib  prefix="form" uri="http://www.springframework.org/tags/form"%>
 
	<!DOCTYPE html>
	<html>
	<head>
	<meta charset="UTF-8">
	<title>Insert title here</title>
	</head>
	<body>
	<h1>员工添加页面</h1>
 
	<form:form action="" modelAttribute="employee">
		 姓名：<form:input path="lastName"/><br/>
		 邮箱：<form:input path="email"/><br/>
		性别:男<form:radiobutton path="gender" value="0"/> 女<form:radiobutton path="gender" value="1"/>
	   部门：<form:select path="department.id" items="${depts}" itemLabel="departmentName" itemValue="id">
		  </form:select>  
		<input type="submit" value="提交"/>
	</form:form>
 
	<!-- 
	  <form action="user" method="post">
	   姓名：<input type="text" name="lastName"><br>
	 邮箱：<input type="text" name="email"/> <br>
	  性别：男<input type="radio" name="gender" value="0"/> 女<input type="radio" name="gender"><br>
	 部门：
	 <select name="department.id">
	   <c:forEach items="${depts }" var="dept" >
	   <option value="${dept.id}">${dept.departmentName}</option>
	   </c:forEach>
	 </select> 
 
	 <input type="submit" value="提交"/>
 
	</form> 
	 -->
 
	</body>
	</html>

	<%pageContext.setAttribute("ctp", request.getContextPath()); %>
    <script src="${ctp}/scripts/jquery-1.9.1.min.js"></script>
	springmvc.xml中加入以下配置即可：
	<mvc:default-servlet-handler/>

    <mvc:annotation-driven conversion-service="conversionService"></mvc:annotation-driven>
    <bean class="org.springframework.context.support.ConversionServiceFactoryBean">
      <property name="converters">
        <set>
          <bean class="com.wuxinzhe.component.StringToEmployeeConverter">
          </bean>
        </set>
      </property>
    </bean>

	<bean class="org.springframework.context.support.ConversionServiceFactoryBean" id="conversionService">
      <property name="converters">
        <set>
          <bean class="com.wuxinzhe.component.StringToEmployeeConverter">
          </bean> 
        </set>
      </property>
    </bean>

	<bean class="org.springframework.format.support.FormattingConversionServiceFactoryBean" id="conversionService">
      <property name="converters">
        <set>
          <bean class="com.wuxinzhe.component.StringToEmployeeConverter">
          </bean> 
        </set>
      </property>
    </bean>

hibernate-validator-5.0.0.CR2.jar
hibernate-validator-annotation-processor-5.0.0.CR2.jar
classmate-0.8.0.jar
jboss-logging-3.1.1.GA.jar
validation-api-1.1.0.CR1.jar

	@Length(min=6,max=8)
	private String lastName;
 
	@Email
	private String email;

	@RequestMapping(value="emps",method=RequestMethod.POST)
	public String addEmp(@Valid Employee employee)

	@RequestMapping(value="emps",method=RequestMethod.POST)
	public String addEmp(@Valid Employee employee,BindingResult result) {
		if(result.hasErrors()) {
			System.out.println("有校验错误");
			return "userAdd";
		}else {
			employees.save(employee);
			System.out.print("添加操作");
			return "redirect:/emps";
		}
	}

<form:errors path="lastName"></form:errors>
<form:errors path="email"></form:errors>

	@RequestMapping(value="emps",method=RequestMethod.POST)
	public String addEmp(@Valid Employee employee,BindingResult result) {
 
		if(result.hasErrors()) {
			List<FieldError> fieldErrors = result.getFieldErrors();
			for(FieldError fieldError:fieldErrors) {
				System.out.println("错误字段"+fieldError.getField());
				System.out.print(fieldError.getDefaultMessage());
			}
			System.out.println("有校验错误");
			return "userAdd";
		}else {
			employees.save(employee);
			System.out.print("添加操作");
			return "redirect:/emps";
		}
	}

Email.employee.email=email format incorrect!!!
Length.lastName=lastName'length between 6 and 8!!!
typeMismatch.birth=birth'format incorrect!!!

Email.employee.email=\u90AE\u7BB1\u683C\u5F0F\u6709\u8BEF\uFF01\uFF01\uFF01
Length.lastName=\u59D3\u540D\u957F\u5EA6\u6709\u8BEF\uFF01\uFF01\uFF01
typeMismatch.birth=\u751F\u65E5\u683C\u5F0F\u6709\u8BEF\uFF01\uFF01\uFF01

    <bean id="messageResource" class="org.springframework.context.support.ResourceBundleMessageSource">
       <property name="basename" value="errors"></property>
    </bean>

jackson-annotations-2.1.5.jar
jackson-core-2.1.5.jar
jackson-databind-2.1.5.jar

	@ResponseBody
	@RequestMapping(value="allemps")
	public Collection<Employee> getAllEmp() {
 
		Collection<Employee> employees =  employeeDao.getAll();
 
		return employees;
 
	}

<script>
 
	var emp = {
		lastName : "哈哈哈",
		email : "qqq@qq.com"
	}
 
	emp = JSON.stringify(emp)
 
	$.ajax({
		url : "${ctp}/requestbody",
		data : emp,
		type : "POST",
		contentType : "application/json",
		success : function() {
 
			alert("发送成功")
		}
	})
</script>

	@RequestMapping(value="requestbody")
	public  String testRequestBody(@RequestBody Employee employee) {
 
		System.out.println(employee);
 
		return "hello";
	}

	@RequestMapping(value="httpEntity")
	public String httpEntity(HttpEntity<String> httpEntity) {
		System.out.println(httpEntity);  //
		return "hello";
	}

<{"lastName":"哈哈哈","email":"qqq@qq.com"},{host=[localhost:8080], connection=[keep-alive], content-length=[45], pragma=[no-cache], cache-control=[no-cache], accept=[*/*], x-requested-with=[XMLHttpRequest], user-agent=[Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/79.0.3945.130 Safari/537.36], origin=[http://localhost:8080], sec-fetch-site=[same-origin], sec-fetch-mode=[cors], referer=[http://localhost:8080/curd/test_ajax.jsp], accept-encoding=[gzip, deflate, br], accept-language=[en-US,en;q=0.9,zh-CN;q=0.8,zh;q=0.7], cookie=[JSESSIONID=2372BBFAF89B035C7624882255336F5D; __jsluid=f0bd1f001ae397d3438d9f7d9c82a8b3; Hm_lvt_d7682ab43891c68a00de46e9ce5b76aa=1559743349], Content-Type=[application/json;charset=UTF-8]}>

	@RequestMapping(value="responseHttpEntity")
	public ResponseEntity<String> responseHttpEntity(){
		MultiValueMap<String,String> headers = new HttpHeaders();
		String body = "<h1>this is a response</h1>";
		headers.add("set-cookie", "11111111111");
		return new ResponseEntity(body,headers,HttpStatus.OK);
	}

	@RequestMapping(value="download")
	public ResponseEntity<byte[]> download(HttpServletRequest request) throws Exception{
		// 获取下载文件的真实路径
		ServletContext context = request.getServletContext();
		String realPath = context.getRealPath("/scripts/jquery-1.9.1.min.js");
		// 读取文件流
		FileInputStream is = new FileInputStream(realPath);
		byte[] tmp = new byte[is.available()];
		is.read(tmp);
		is.close();
 
		HttpHeaders headers = new HttpHeaders();
		headers.set("Content-Disposition", "attachment;filename=jquery-1.9.1.min.js");
		return new ResponseEntity<byte[]>(tmp,headers,HttpStatus.OK); 
	}

	    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
         <property name="maxUploadSize" value="#{1024*1024*20}"></property>
         <property name="defaultEncoding" value="utf-8"></property>
    </bean>

	@RequestMapping(value="upload")
	public String upload(@RequestParam(value="username",required=false) String userName,@RequestParam(value="headerimg")MultipartFile file,Model model) {
 
		System.out.println(userName);
		System.out.println(file);
		System.out.println("文件大小"+file.getSize());
		System.out.println("文件名字"+file.getName());
		System.out.println("文件原始名字"+file.getOriginalFilename());
		System.out.println("文件类型"+file.getContentType());
 
		try {
			file.transferTo(new File("C:\\Users\\Dell\\Desktop\\demo\\"+file.getOriginalFilename()));
			model.addAttribute("msg","文件上传成功");
		} catch (Exception e) {
			model.addAttribute("msg", "文件上传失败");
		} 
 
		return "hello";
	}

package com.wuxinzhe.component;
 
import java.util.Locale;
 
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import org.springframework.web.servlet.LocaleResolver;
 
public class MyLocaleResolver implements LocaleResolver {
 
	@Override
	public Locale resolveLocale(HttpServletRequest request) {
 
		Locale locale = null;
		String localeStr = request.getParameter("locale");
 
		if (localeStr != null && !"".equals(localeStr)) {
			// 通过参数，返回参数对应的区域信息
			String[] localInfo = localeStr.split("_");
			return new Locale(localInfo[0],localInfo[1]);
 
		}else {
			// 通过请求获取默认的区域信息
			return request.getLocale();
		}
	}
 
	@Override
	public void setLocale(HttpServletRequest request, HttpServletResponse response, Locale locale) {
	}
}

    <bean id="localeResolver" class="com.wuxinzhe.component.MyLocaleResolver">
    </bean>

    <!-- 区域信息从session中获取 -->
    <bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
    </bean>

	@RequestMapping(value="/login")
	public String login(@RequestParam(value="locale",defaultValue="zh_CN") String localeStr,Locale locale,HttpSession session) {
 
		String[] localeInfo = localeStr.split("_");
 
		session.setAttribute(SessionLocaleResolver.class.getName()+".LOCALE", new Locale(localeInfo[0],localeInfo[1]));
 
		return "login";
	}

    <!-- 区域信息从session中获取 -->
    <bean id="localeResolver" class="org.springframework.web.servlet.i18n.SessionLocaleResolver">
    </bean>
    <bean class="org.springframework.web.servlet.i18n.LocaleChangeInterceptor">
    </bean>

	@ExceptionHandler(Exception.class)
	public ModelAndView exceptionHandler(Exception exception) {
 
		ModelAndView view = new ModelAndView("success");
 
		view.addObject("exception", exception);
 
		return view;
	}

@ControllerAdvice
public class ExceptionTestController {
 
	@RequestMapping(value="caculate")
	public String caculate() {
 
		Integer i = 10/0;
 
		return "hello";
	}
}

package com.wuxinzhe.controller;
 
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
 
@ResponseStatus(reason = "用户未找到", value = HttpStatus.NOT_ACCEPTABLE)
public class UserNotFoundException extends RuntimeException {
 
	//private static final long serialVersionUID = 1L;
 
}

	@RequestMapping(value="caculate")
	public String caculate() {
		if(true) {
			throw new UserNotFoundException();
		}
		return "success";
	}

	<!-- needed for ContextLoaderListener -->
	<context-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:spring.xml</param-value>
	</context-param>
 
	<!-- Bootstraps the root web application context before servlet initialization -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>
 
  <servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>classpath:springmvc.xml</param-value>
    </init-param>
  </servlet>
  <servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

  	<!-- use-default-filters过滤所有，需要禁用 -->
	<context:component-scan base-package="com.wuxinzhe" use-default-filters="false">
	  <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
	  <context:include-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>  
	</context:component-scan>

  <context:component-scan base-package="com.wuxinzhe">
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <context:exclude-filter type="annotation" expression="org.springframework.web.bind.annotation.ControllerAdvice"/>    
  </context:component-scan>

    @Autowired BookController bookController;
	public BookService() {
		System.out.println("bookService");
	}

mybatis-3.4.1.jar
log4j-1.2.17.jar
mysql-connector-java-5.1.48-bin.jar

package com.wuxinzhe.bean;
 
public class Employee {
 
	private Integer id;
 
	private String employeeName;
 
	private Integer gender;
 
	public Employee() {
		super();
	}
 
	public Employee(Integer id, String employeeName, Integer gender) {
		super();
		this.id = id;
		this.employeeName = employeeName;
		this.gender = gender;
	}
 
	public Integer getId() {
		return id;
	}
 
	public void setId(Integer id) {
		this.id = id;
	}
 
	public String getEmployeeName() {
		return employeeName;
	}
 
	public void setEmployeeName(String employeeName) {
		this.employeeName = employeeName;
	}
 
	public Integer getGender() {
		return gender;
	}
 
	public void setGender(Integer gender) {
		this.gender = gender;
	}
 
	@Override
	public String toString() {
		return "Employee [id=" + id + ", employeeName=" + employeeName + ", gender=" + gender + "]";
	}
}

package com.wuxinzhe.dao;
 
import com.wuxinzhe.bean.Employee;
 
public interface EmployeeDao {
	// 获取某个雇员信息
	public Employee getEmployeeById(Integer Id);
	// 更新某个雇员信息
	public Integer updateEmp(Employee employee);
	// 添加某个雇员信息
	public Integer insertEmp(Employee employee);
	// 删除某个雇员信息
	public boolean deleteEmp(Integer Id);
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
  PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
 
   <!-- properties引入外部配置文件
        resource从类路径下引入
        url从磁盘或者网络路径引入
   -->
   <properties resource="dbconfig.properties"></properties>
    <settings>
       <!-- javabean属性名驼峰str1Str2 自动对应    数据表字段 str1_str2 -->
       <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
 
    <typeAliases>
       <!-- ①为一个javabean起别名，方便引用   引用名默认就是类名，也可以使用alias属性可以指定一个新的别名 -->
       <!-- <typeAlias type="com.wuxinzhe.bean.Employee" /> -->
       <!-- ②批量起名 默认名字就是包名，也可以通过Alias注解在类上重新命名 -->
       <package name="com.wuxinzhe.bean"/>
       <!-- 不建议使用别名，因为别名不利于读 -->
    </typeAliases>
 
  <environments default="development">
    <environment id="development">
      <transactionManager type="JDBC"/>
      <dataSource type="POOLED">
        <property name="driver" value="${driver}"/>
        <property name="url" value="${url}"/>
        <property name="username" value="${username}"/>
        <property name="password" value="${password}"/>
      </dataSource>
    </environment>
  </environments>
 
  <!-- 注册写好的sql映射文件 -->
  <mappers>
    <!-- <mapper resource="employee.xml"/> -->
 
    <!-- 批量注册映射文件 -->
    <!-- 批量注册文件名必须对应dao名称 -->
    <package name="com.wuxinzhe.dao" />
  </mappers>
</configuration>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
  PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wuxinzhe.dao.EmployeeDao">
  <select id="getEmployeeById" resultType="Employee">
    select * from t_employee where id = #{id}
  </select>
 
   <insert id="insertEmp">
         INSERT INTO t_employee(employeeName,gender) VALUES(#{employeeName},#{gender})
   </insert>
 
   <update id="updateEmp">
       UPDATE t_employee SET employeeName=#{employeeName},gender=#{gender} WHERE id=#{id}
   </update>
 
   <delete id="deleteEmp">
      DELETE * FROM t_employee WHERE id=#{id}
   </delete>
 
</mapper>

package com.wuxinzhe.test;
 
import static org.junit.jupiter.api.Assertions.*;
 
import java.io.IOException;
import java.io.InputStream;
 
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
 
import com.wuxinzhe.bean.Employee;
import com.wuxinzhe.dao.EmployeeDao;
 
class MyBatisTest {
 
	SqlSessionFactory sqlSessionFactory;
 
	@BeforeEach
	public void initSqlSessionFatctory() throws IOException {
		String resource = "mybatis-config.xml";
		InputStream inputStream = Resources.getResourceAsStream(resource);
		sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
	}
 
	@Test
	void test() throws IOException {
		//根据全局配置文件创建一个SqlSessionFactory
		// SqlSessionFactory是SqlSession工厂，负责创建从中获得 SqlSession 的实例
		// SqlSession：sql会话（代表和数据库的一次会话）
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			//获取dao接口实现
			EmployeeDao employeeDao = sqlSession.getMapper(EmployeeDao.class);
			Employee employee = employeeDao.getEmployeeById(1);
			System.out.println(employee);
		} finally {
			sqlSession.close();
		}
	}
 
	@Test
	void InsertEmp() {
		SqlSession sqlSession = sqlSessionFactory.openSession();
		try {
			EmployeeDao employeeDao = sqlSession.getMapper(EmployeeDao.class);
			employeeDao.insertEmp(new Employee(null,"哈哈哈",1));
		}finally {
			sqlSession.close();
		}
	}
 
}

   <insert id="insertEmp" useGeneratedKeys="true" keyProperty="id">
         INSERT INTO t_employee(employeeName,gender) VALUES(#{employeeName},#{gender})
   </insert>

   <insert id="insertEmp2">
      <selectKey order="BEFORE" keyProperty="id" resultType="integer">
         SELECT max(id)+1 FROM t_employee
      </selectKey> 
      INSERT INTO t_employee(id,employeeName,gender) VALUES(#{id},#{employeeName},#{gender})
   </insert>

  <select id="getEmployeeByIdAndEmpname" resultType="Employee">
    select * from t_employee where id = #{id} AND employeeName=#{empName}
  </select>

  public List<Employee> allEmps();
  </[re?>
  	<pre lang="conf" escaped="true">
  <select id="allEmps" resultType="Employee">
     SELECT * FROM t_employee
  </select>

  public Map<String,Object> getEmpByIdReturnMap(Integer id);

  <select id="getEmpByIdReturnMap" resultType="map">
      SELECT * FROM t_employee WHERE id=#{id}
  </select>