代码示例

Spring Basic

helloSpring × XML

前言

1. 一个简单的，使用XML配置的Spring起手示例
2. 展示IOC的控制反转
3. 关键点
   1. 初识 Spring IOC。
   2. IOC是什么？DI又是什么？

关系

基础类

POM.xml

配置MAVEN

<dependency> 
      <groupId>org.springframeworkgroupId>  
      <artifactId>spring-contextartifactId>  
      <version>5.0.2.RELEASEversion> 
dependency>  

UserDao.java

数据库访问层

//关键点：

//1. 路径：cn.ningbaiyu.Dao.IMPL.UserDao.java
//2. 普通的接口实现类。

public interface IUserDao{
    void save(){}
}

public class userDao implement IUserDao{
    @Override/*这是重写接口的方法*/
    public void save(){
        sout.save;
    }
}

ApplicationContext.xml

配置Spring属性

<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" class="cn.ningbaiyu.Dao.Impl.UserDao"/>
    
beans>

Test.java

一个执行类

//关键点：

//1. ClassPathXMLApplicationContext，类路径xml应用程序上下文。
//2. Object getBean(String ApplicationContext.xml.bean.id)。
//3. 必须完成1、2。Spring IOC才能创建对象。

public class Test{

	@Test
	public void test(){
		ClassPathXmlApplicationContext ac =new ClassPathXmlApplicationContext("ApplicationContext.xml");
		
		IUserDao userDao = (IUserDao)ac.getBean("userDao")
		
		userDao.save();
	}
}

执行结果

save

helloAOP × XML

前言

1. 一个简单的，使用XML配置的AOP起手示例
2. AOP基于日志业务的扩展示例
3. 关键点：
   1. 这个示例是基于SpringAOP实现的。
   2. SpringAOP底层是JDK动态代理+Cglib动态代理组成的。这里理应有JDK动态代理和Cglib动态代理的示例。但是由于时间关系，就不赘述了。
   3. JDK动态代理，代理对象通过getClass()方法能看出，前缀包含$Proxy
   4. Cglib动态代理，代理对象通过getClass()方法能看出，后缀包含Cglib

关系

extend helloSpring × xml

POM.xml

super.get(POM.xml)



<dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.8.7version>
dependency>

AopLog.java

一个简单的类

//路径：cn.ningbaiyu.AOP.AopLog

public class AopLog {
		/*对应，执行前打印日志*/
    public void before() {
        System.out.println("before=====>");
    }

    /*
    *//*对应，执行后打印日志*//*
    public void after() {
        System.out.println("after=====>");
    }

    *//*对应，执行后最终状态打印日志*//*
    public void afterReturning() {
        System.out.println("afterReturning=====>");
    }
    *//*对应，执行后异常状态打印日志*//*
    public void afterThrowing() {
        System.out.println("afterThrowing=====>");
    }

    *//*环绕通知，将所有通知写进同一个方法*//*
    *//*这里边有个重要的东西，ProceedingJoinPoint*//*
    *//*它的实例，proceed方法是通过反射的方式调用执行对象的。*//*
    public Object around(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("aroundBefore=====>");
            *//*在有返回值的情况下，需要实例化返回值*//*
            Object proceed = joinPoint.proceed();
            System.out.println("aroundAfter=====>");
            *//*判断是否为空，然后返回*//*
            if (proceed!=null) {
                return proceed;
            }
        } catch (Throwable throwable) {
            System.out.println("afterThrowing=====>");
            throwable.printStackTrace();
        } finally {
            System.out.println("afterReturning=====>");
        }
        return null;
    }*/
}

UserDao.java

super.get(UserDao.java)

applicationContext.xml

super.get(applicationContext.xml)

<bean id="aopLog" class="cn.ningbaiyu.AOP.AopLog"/>

<aop-config>
	<aop-aspect ref="aopLog">
    	<aop-pointcut id="pc" expression="execution(* cn.ningbaiyu.Dao.Impl.UserDao.*(..))/>"/>
        <aop-before method="before" pointcut-ref="pc"/>
    aop-aspect>
aop-config>

Test.java

一个执行类

super.get(UserDao.java)

执行结果

before=====>
save

Spring × AOP × XML

前言

1. 普通的，使用XML配置的，包含AOP模块的Spring示例
2. IOC的自动封装
3. 新增IUserService接口和UserService实现类

关系

extend helloAOP.xml

POM.xml

super.get(POM.xml)

AopLog.java

super.get(AopLog.java)

UserDao.java

super.get(User.java)

UserService.java

//接口
public interface IUserService {
    void save();
}

//实现类
public class UserService implements IUserService {

    /**
     * 关键词：
     * IOC控制反转
     * 通过Setter方法赋值
     */

    //创建一个没有实例化的userDao私有成员对象
    //注意这个对象没有数据的，设计交给Spring实例化，赋值的
    private IUserDao userDao ;

    //通过Xml配置的Spring，实例化对象后，是通过Setter方法赋值的
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }

    @Override/*这是重写接口的方法*/
    public void save() {
        //增加不同的地方，让测试更好识别。
        System.out.println("i am UserService");
        //调用私有成员的方法
        userDao.save();
    }
}

ApplicationContext.xml

    
    
<bean id="userService" class="cn.ningbaiyu.Service.Impl.UserService">
    
    
    
    <property name="userDao" ref="userDao"/>
bean>

Test.java

super.get(Test.java)
     
@Test
public void test2(){

ClassPathXmlApplicationContext ac =new ClassPathXmlApplicationContext("ApplicationContext.xml");

IUserService userService = (IUserService) ac.getBean("userService");

userService.save();

}

执行结果

i am UserService
before=====>
save

Spring × AOP × JDBC × XML

前言

1. 使用XMl配置，使用AOP，使用JDBC的Spring示例
2. 更复杂的IOC自动封装例子。
3. 新增Pojo.User

关系

extend Spring × AOP × XML

POM.xml

super.get(POM.xml)




<dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.40version>
dependency>


<dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>5.0.2.RELEASEversion>
dependency>


<dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.10version>
    dependency>
<dependency> 

AopLog.java

super.get(AopLog.java)
 

User.java

public class User {
    
    /*
    关键点
    
    1. 这个类是设计来封装数据库的表数据。所以要完全吻合表数据的所有数据名称。
    */
    
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
 
    parameter.getter
	parameter.setter
        
	class.Constructor()
	class.Constructor(all parameter)
}

UserDao.java

super.get(UserDao.java)
	
    //接口新增方法
    List<User> findAll();

	/*
	关键点
	1. 使用Spring框架，类的所有私有成员都需要提供getter和setter方法才能被Spring IOC创建。
	*/
    
    //创建JdbcTemplate私有成员
    //交给Spring，通过Setter方法赋值
    private JdbcTemplate jdbcTemplate;
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }


    @Override/*这是重写接口的方法*/
    public List<User> findAll() {
        
        //通过JdbcTemplate.query获取所有用户的数据
        List<User> userList = 
            jdbcTemplate.query("SELECT * FROM `user`", new BeanPropertyRowMapper<>(User.class));
       
        //返回用户数据集合
        return userList;
    }

UserService.java

super.get(UserService.java)
	
    //接口新增方法
    void findAll();

	    @Override/*这是重写接口的方法*/
    public void select() {
        
        List<User> userList = userDao.findAll();
        
        for (User user : userList) {
            System.out.println("user = " + user);
        }
        
    }

ApplicationContext.xml

super.get(ApplicationContext.xml)
    
    <bean id="dataresource" class="com.alibaba.Druid.pool.dataResource">
		<properties name="url" value="jdbc:mysql://localhost:3306/spring_02?characterEncoding=UTF8"/>
		<properties name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<properties name="username" value="root"/>
        <properties name="password" value="root"/>
	bean>

    <bean id="JdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataResource"/>
    bean>

	@Override
	<bean id="userDao" class="cn.ningbaiyu.Dao.Impl.UserDao">
        <property name="jdbcTemplate" ref="JdbcTemplate"/>
    bean>

Test.java

super.get(Test.java)
    
        @Test
    public void test3(){
    
        ApplicationContext ac =new ClassPathXmlApplicationContext("ApplicationContext.xml");
    
        IUserService userService = (IUserService) ac.getBean("userService");
    
        userService.select();
    }

执行结果

before=====>

user = User{id=41, username='老王', birthday=2018-02-27 17:47:08.0, sex='男', address='北京'}
user = User{id=42, username='小二王', birthday=2018-03-02 15:09:37.0, sex='女', address='北京金燕龙'}

Spring × AOP × JDBC × Transaction × XML

前言

1. SpringIOC，SpringAOP，SpringJDBC，SpringTransaction，通过配置XML的方式实现。
2. 关键点
   1. SpringTX实质上属于AOP的环绕通知。当AOP存在SpringTX和另一个环绕通知的时候，另一个环绕通知会失效。
   2. 事实性步骤
      1. 创建bean标签，id为transactionManager指向jdbc.datasource.DataSourceTransactionManager。注入用Druid创建的数据源。
         1. 这意味着，事务管理器是用jdbc的数据源事务管理器，那么我也可以用其他来源的数据事务管理器。
         2. 创建bean标签，意味着将jdbc的数据源事务管理器交给SpringIOC容器管理。
      2. 创建tx:advice（通知）标签，transaction-manager（事务管理器）注入transactionManager，在子标签tx:attributes（属性），配置transactionManager的属性。
         1. 这样就很明了，拿到JDBC的数据源事务管理器，通过tx:Advice配置这个数据源事务管理器的属性。
         2. 属性是什么？指向绑定的方法，配置只读，传递等等的属性。这个暂时还未深入去理解。
      3. 创建aop:config（配置）标签，创建aop:point子标签，创建aop:advisor（顾问）子标签。在aop:point切入点配置被切入代码。在aop:advisor配置插入的事务管理以及应用在哪个切点
         1. 从这里出发，纵览全局。证明了SpringTX实质上属于AOP的环绕通知这个观点。插入的事务是环绕着被切入代码运行的。

关系

extend Spring × AOP × JDBC × XML

2019年7月16日-新改革

从这天开始，不再写具体继承，只写改变的状态以及更新的点。
以前写具体继承的示例有：
1.Spring入门除了本示例以外的所有示例
2.SpringMVC所有示例

改变的状态，比如完全重写：@Override。
更新的点，直接标继承的文件，然后写更新的点。

POM.xml

<dependency>
  <groupId>org.springframeworkgroupId>
  <artifactId>spring-txartifactId>
  <version>5.0.2.RELEASEversion>
dependency>

ApplicationContext.xml

  
    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
        <property name="dataSource" ref="dataResource"/>
    bean>

    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        
        <tx:attributes>
            
            
            <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="query*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="select*" read-only="true" propagation="SUPPORTS"/>
            <tx:method name="search*" read-only="true" propagation="SUPPORTS"/>
            
            
            <tx:method name="*" read-only="false" propagation="REQUIRED"/>
            
        tx:attributes>
    tx:advice>

		
    <aop:config>
      	
        <aop:pointcut id="txPC" expression="execution(* cn.ningbaiyu.Service.Impl.*Service.*(..))"/>
        
      	
      	<aop:advisor advice-ref="txAdvice" pointcut-ref="txPC"/>
      	
      	 
    aop:config>
		
    
    
    	

UserDao.java

		/*新增`增加方法*/
		
		/*接口*/
		IUserDao.java{
		boolean AddUser(User user)
		}
		
		/*实现类*/
		@Override
    public boolean AddUser(User user) {
        int update = jdbcTemplate.update("INSERT into `user` " +
                "values (null,?,?,?,?)", user.getUsername(), user.getBirthday(), user.getSex(), user.getAddress());
        return update != 0;
    }

UserService.java

	/*新增`增加方法*/

	/*接口*/
	IUserService.java{
  		boolean AddUser(User user);
  }

	/*实现类*/
	@Override
	public boolean AddUser(User user) {
        userDao.AddUser(user);
        int i = 10 / 0;//制造运行时异常，测试事务是否回滚
        userDao.AddUser(user);
    		
    		//这里一共插入两条数据。如果正常回滚的话，异常之前的插入数据将会被回滚。
    		//也就是这里的第一条插入数据，遇到异常时候，在事务管理下将会失效。
    		
        return false;//不要在乎这个返回值。
	}

Test.java

    @Test
    /*测试事务回滚*/
    public void test4(){
      	//常规创建IOC容器
        ApplicationContext ac =new ClassPathXmlApplicationContext("ApplicationContext.xml");
        //从ApplicationContext.xml取得“userService“标签
      	//得到标签中所指向的类路径，创建类。
      	IUserService userService = (IUserService) ac.getBean("userService");

      	//通过打印getClass()方法，查看该对象是否被事务管理器代理
        System.out.println("userService = " + userService.getClass());

      
      	//创建参数对象
        User user =new User();
        user.setSex("男");
        user.setAddress("北极");
        user.setUsername("南锣");
        user.setBirthday(new Date());
				
      	//注入参数，执行方法
        userService.AddUser(user);

    }

执行结果

//这是打印getClass方法
//通过其后缀可以看出，“userService”对象已经被Cglib动态代理
//如果前缀是$porxy，则是被JDK动态代理
userService = class cn.ningbaiyu.Service.Impl.UserService$$EnhancerBySpringCGLIB$$3816a0bd

//AOP插入的日志信息
before=====>

//打印的异常
java.lang.ArithmeticException: / by zero

//由于Mysql没有打印信息，但是实际上由于事务回滚，MySQL并没有被插入信息。
//所以这次事务管理是成功的。

Spring × AOP × JDBC × Transaction × Annotation

前言

1. 基于Spring × AOP × JDBC × Transaction × XML示例实现全注解。

2. 关键注解：

   1. 声明需要Spring IOC容器注入数据的属性

3. @Autowired

4. 声明其他类

   1. @Component；让Spring IOC容器识别这是需要其管理的类，并纳入IOC容器中。
      1. pojo.javabeen类
      2. Aspect类
      3. 需要引入的类

5. 声明数据库访问层的类

   1. @Repository；
      1. 类似@Component，主要是给Spring IOC容器识别的。
      2. 让Spring IOC容器识别这是数据访问层的类，并纳入IOC容器中。

6. 声明业务层的类

   1. @Service；
      1. 类似@Component，主要是给Spring IOC容器识别的。
      2. 让Spring IOC容器识别这是业务层的类，并纳入IOC容器中。

7. 声明配置类

   1. @Configuration；
      1. 类似@Component，主要是给Spring IOC容器识别的。
      2. 声明这是配置类
      3. @ComponentScan（包的类路径）；
         1. 启用包扫描，扫描哪些类有注解。
      4. @Import（引入类.class）；
         1. 引入其他类。
         2. 这里目的是引入写满Bean标签的类。
      5. @EnableAspectJAutoProxy（）；
         1. 启用AOP扫描，扫描哪些类被声明为Aspect（切面）。
         2. proxy Target Class 意思是代理目标类，true=使用JDK动态代理，false=Cglib动态代理)；
      6. @EnableTransactionManagement；
         1. 启用事务管理器扫描，扫描哪些类被声明为事务切入点

8. 声明需要被事务管理的类或方法

   1. @Transactional；
      1. 我想到了为什么！这个注解是标识类或方法为切入点，从而进行事务插入。我自己生造了一个术语，事务切入点。
      2. 等同于！！

9. 声明切面（Aspect）类

   1. @Aspect；声明这是切面类。

   2. @Pointcut(“切入点(切入点全路径)”)；声明这是一个id为方法名的切入点。

   3. @Before(“切入点的名称()”)；声明这是切入点代码执行前插入的方法。

10. 导入外部配置文件，注入配置文件的数据。

    1. @PropertySource(配置文件的全路径)；导入配置文件。
    2. @Value("${配置文件中的key}")；获取配置文件中的key，注入所注解的属性，配合@PropertySource使用

11. 关键代码

    1. JdbcConfig.java
    2. SpringConfig.java
    3. logAspsect.java

关系

@Override Spring × AOP × JDBC × Transaction × XML

POM.xml

<dependencies>
      
      
      <dependency>
          <groupId>org.springframeworkgroupId>
          <artifactId>spring-contextartifactId>
          <version>5.0.2.RELEASEversion>
      dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-testartifactId>
      <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>org.aspectjgroupId>
      <artifactId>aspectjweaverartifactId>
      <version>1.8.13version>
    dependency>
    
    <dependency>
      <groupId>org.springframeworkgroupId>
      <artifactId>spring-jdbcartifactId>
      <version>5.0.2.RELEASEversion>
    dependency>
    
    <dependency>
      <groupId>com.alibabagroupId>
      <artifactId>druidartifactId>
      <version>1.1.10version>
    dependency>
    
    <dependency>
      <groupId>mysqlgroupId>
      <artifactId>mysql-connector-javaartifactId>
      <version>5.1.5version>
    dependency>
    
    <dependency>
      <groupId>junitgroupId>
      <artifactId>junitartifactId>
      <version>4.12version>
    dependency>
  dependencies>  

User.java

@Component
//JAVABean类
//@Component；让Spring IOC容器识别这是需要其管理的类，并纳入IOC容器中。
public class User {
    private Integer id;
    private String username;
    private Date birthday;
    private String sex;
    private String address;
  
  //getter&setter&@Override ToString
  
    }

UserDao.java

//接口
public interface IUserDao {
    public boolean add(User user);
    public List<User> findAllUser();
}

@Repository
//@Repository；类似@Component，主要是给Spring IOC容器识别的。
//让Spring IOC容器识别这是数据访问层的类，并纳入IOC容器中。
public class UserDaoIMPL implements IUserDao {
    @Autowired
    //自动注入jdbcTemplate
    private JdbcTemplate jdbcTemplate;

    @Override
  	//这是重写接口的方法
    public boolean add(User user) {
        int update = jdbcTemplate.update(
                "INSERT INTO `USER` VALUES (NULL,?,?,?,?)",
                user.getUsername(),
                user.getBirthday(),
                user.getSex(),
                user.getAddress());
        return update > 0;
    }

    @Override
  	//这是重写接口的方法
    public List<User> findAllUser() {
        List<User> userList = jdbcTemplate.query("SELECT * FROM `USER`", new BeanPropertyRowMapper<>(User.class));
        return userList;
    }
}

UserService.java

//接口
public interface IUserService {
    public void add(User user);
    public List<User> findAllUser();
}

//实现类
@Service
//@Service；类似@Component，主要是给Spring IOC容器识别的。
//让Spring IOC容器识别这是业务层的类，并纳入IOC容器中。
@Transactional
public class UserServiceIMPL implements IUserService {
    @Autowired
    private IUserDao userDao;

    @Override
    public void add(User user) {
      
      userDao.add(user);
      	
      int i = 10 / 0;//制造运行时异常，测试事务是否回滚
    	
x    		//这里一共插入两条数据。如果正常回滚的话，异常之前的插入数据将会被回滚。
    		//也就是这里的第一条插入数据，遇到异常时候，在事务管理下将会失效。
       
      userDao.add(user);
      
    }

    @Override
    public List<User> findAllUser() {
        List<User> userList = userDao.findAllUser();
        return userList;
    }
}

SpringConfig.java

@Configuration
//@Configuration；声明这是配置类
@Import(JdbcConfig.class)
//@Import（引入类.class）；引入其他类。这里的目的是引入写满Bean标签的类。
@ComponentScan("cn.ningbaiyu")
//@ComponentScan（包的类路径）；启用包扫描，扫描哪些类有注解。
@EnableAspectJAutoProxy(proxyTargetClass = true)
//@EnableAspectJAutoProxy((proxy Target Class代理目标类),true意味着使用JDK动态代理，false意味着使用Cglib动态代理)；
//启用AOP扫描，扫描哪些类被声明为Aspect
@EnableTransactionManagement
//@EnableTransactionManagement；启用事务管理器扫描，扫描哪些类被声明为事务切入点
public class SpringConfig {
}

JdbcConfig.java

@PropertySource("jdbc.properties")
//@PropertySource(配置文件的全路径)；导入配置文件。
@Component
//@Component；让Spring IOC容器识别这是需要其管理的类，并纳入IOC容器中。
public class JdbcConfig {

    @Value("${jdbc.url}")
    //@Value("${配置文件中的key}")；获取配置文件中的key，注入所注解的属性
    private String url;

    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    @Bean
    //@Bean；XML文件中的bean标签，这意味着，Spring IOC容器将以此新建对象。
    private DataSource createDataSource(){
        //实例化德鲁伊数据源对象
        DruidDataSource dataSource =new DruidDataSource();
        //注入各种属性
        dataSource.setUrl(url);
        dataSource.setDriverClassName(driver);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        //返回数据对象
        return dataSource;
    }

    @Bean
    private JdbcTemplate createJdbcTemplate(DataSource dataSource){
        //实例化JDBC连接池对象，注入德鲁伊数据源对象，并且返回
        return new JdbcTemplate(dataSource);
    }

    @Bean
    private DataSourceTransactionManager createDBTransactionManager(DataSource dataSource){
        //JDBC数据源事务管理对象
        DataSourceTransactionManager dbTransactionManager = new DataSourceTransactionManager();
        //注入德鲁伊数据源
        dbTransactionManager.setDataSource(dataSource);
        //返回JDBC数据源事务管理对象
        return dbTransactionManager;
      
      //这段代码加上@trasational所注解的类或方法，相当于
      //
      	//
      	//             pointcut-ref="@trasational所注解的类或方法"/>
      //
      
      
    }

}

LogAspect.java

@Aspect
// @Aspect;声明这是切面类。
@Component
//@Component；让Spring IOC容器识别这是需要其管理的类，并纳入IOC容器中。
public class logAspect {

    @Pointcut("execution(* cn.ningbaiyu.Service.IMPL.*ServiceIMPL.*(..))")
    //execution，执行
    //@Pointcut("切入点(切入点全路径)")；声明这是一个id为方法名的切入点。
    public void pc(){}

    @Before("pc()")
    //@Before("切入点的名称()")；声明这是插入的方法。
    public void testBefore(){
        System.out.println("before====>");
    }

    @After("pc()")
    public void testAfter(){
        System.out.println("after====>");
    }

//    @AfterReturning("pc()")
//    public void AfterReturning(){
//        System.out.println("AfterReturning====>");
//    }

    @AfterThrowing("pc()")
    public void testAfterThrowing(){
        System.out.println("AfterThrowing====>");
    }

//相当于
//
//
//  
//  
//  
//  
//
}

Test.java

@RunWith(SpringJUnit4ClassRunner.class)
//@RunWith（Spring和Junit整合的类）；Spring与Junit整合，指向整合类
@ContextConfiguration(classes = SpringConfig.class)
//@ContextConfiguration(配置文件或配置类)；Spring与Junit整合，指向配置文件或配置类。
public class Test {
    @Autowired
    private IUserService userService;

    @org.junit.Test
    public void findAllUser(){
        System.out.println("userService.getClass() = " + userService.getClass());
        List<User> userList = userService.findAllUser();
        for (User user1 : userList) {
            System.out.println("user = " + user1);
        }
    }

    @org.junit.Test
    public void add(){
        System.out.println("userService.getClass() = " + userService.getClass());

        User user = new User();
        user.setSex("女");
        user.setAddress("北京");
        user.setUsername("aa");
        user.setBirthday(new Date());


        userService.add(user);
    }

}

#MyBatis Basic

SpringMVC Basic

helloSpringMVC

前言

1. 一个简单的SpringMVC起手示例
2. 转发JSP（动态资源）
3. 关键点：
   1. DispatcherServlet
   2. 开启MVC注解驱动：创建处理器映射器 和 处理器适配器

POM.xml

        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-webmvcartifactId>
            <version>5.0.2.RELEASEversion>
        dependency>

WEB.xml

   <servlet>
      <servlet-name>dispatcherServletservlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
       
      <init-param>
          
         <param-name>contextConfigLocationparam-name>
          
         <param-value>classpath:springMVC.xmlparam-value>
      init-param>
       
      <load-on-startup>1load-on-startup>
   servlet>

   <servlet-mapping>
       
      <servlet-name>dispatcherServletservlet-name>
       
      <url-pattern>*.dourl-pattern>
   servlet-mapping>

HelloController.java

package cn.ningbaiyu.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
//@Controller等同于@Component。
//声明类而已，方便IOC容器识别。
//这个类中的所有方法，加上@RequestMapping后，都成为了Servlet！
public class HelloController {
    @RequestMapping("/hello.do")
    public String hello(){
        System.out.println("正在处理请求和响应...");
        return "success";
    }
}

springMVC.xml

<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:mvc="http://www.springframework.org/schema/mvc"
       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/mvc
       http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    
  	
    <context:component-scan base-package="cn.ningbaiyu.controller"/>

    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        
        <property name="prefix" value="/pages/"/>
        
        <property name="suffix" value=".jsp"/>
    bean>

    
    <mvc:annotation-driven/>
    
   
beans>

success.jsp

success!

执行结果

success.jsp.show success!

HelloController.java.sout.正在处理请求和响应...

springMVC × DispatcherServlet

前言

1. 测试dispatcherServlet配置通配地址
2. 关键点：
   1. dispatcherServlet
   2. WEB.xml.servlet-mapping.url-pattern

关系

extend helloSpringMVC

arr={POM.xml,WEB.xml,HelloController.java,springMVC.xml,success.jsp}

super.get(arr)

客户端

http://localhost:8080/hello.do

WEB.xml

super.get(WEB.xml)



-->

@Override（method）
<servlet-mapping>
	<servlet-name>dispatcherServletservlet-name>
    
    <url-pattern>/url-pattern>
servlet-mapping>

springMVC × HTML

前言

1. 通过springMVC访问HTML的三种写法（springMVC访问静态资源的三种解决方案）。所以需要注意的是，本示例是同一案例的三种解决方案，解决方案都可以单独使用。

2. 关键点

   1. tomcat.conf.web.xml.DefultServlet
   2. mvc:default-servlet-handler（***）
   3. mvc:resources

3. 新增successHTML.html

关系

extend springMVC × dispatcherServlet

arr={POM.xml,WEB.xml,HelloController.java,springMVC.xml,success.jsp}

super.get(arr)

客户端

//关键点：
//这里请求successHTML.html的方法有别于父类的请求jsp的方法。
//1. 父类请求jsp的方法，是走Servlet（HelloController）进行判断，再转发至jsp的
//2. 这里请求successHTML.html是直接走项目地址的，直接访问successHTML.html的


http://localhost:8080/pages/successHTML.html

successHTML.html

i am html5!!!

WEB.xml

第二种解决方案

	


<servlet-mapping>
	<servlet-name>defaultservlet-name>
	<url-pattern>*.htmlurl-pattern>
	<url-pattern>*.cssurl-pattern>
	<url-pattern>*.jsurl-pattern>
servlet-mapping>

SpringMVC.xml

第二种解决方案

<mvc:resources mapping="/pages/**" location="pages/"/>
<mvc:resources mapping="/index.html" location="/index.html"/>

SpringMVC.xml

第三种解决方案（***）

<mvc:default-servlet-handler/>

springMVC × Model&ModelMap

前言

1. SpringMVC收到的请求数据储存在request请求域（SpringMVC走请求域）的方法
2. 关键点：
   1. Model
   2. ModelMap
   3. BindingAwareModelMap
   4. 走请求域，就意味着动态，动态就意味着JSP。它们的关系是，SpringMVC（model/modelMap）->请求域->jsp

关系

extend springMVC × HTML(solution = 3)

arr={
POM.xml,
WEB.xml,
HelloController.java,
springMVC.xml,
successHTML.html,
success.jsp
};

super.get(arr);

JSP index.jsp = new JSP;//新增一个index.jsp

@Override(class)
HelloController.java;

客户端

http://localhost:3306/textModel

http://localhost:3306/textModelMap

index.jsp

//关键词：
//${}是el表达式，整条句子的意思是获取request域中的名为cn的键的值。

cn:${requestScope.cn}<br/>
//实际显示"cn","china"
us:${requestScope.us}<br/>
//实际显示"us","American"

HelloController.java

    
		@RequestMapping("/testModel")
    public String goTestModel(Model model){
        model.addAttribute("cn","china");
        return "index";
    }

		//响应的URI
    @RequestMapping("/testModelMap")
    public String goTestModelMap(Model model){
      //为什么Model得走方法的形参？	
      //我感觉SpringMVC扫描该方法的参数，知道这个方法要用Model。然后…注入Model的实现类，做到走请求域的需求。 
        model.addAttribute("us","American");
      	//转发至index.jsp
        return "index";
    }

springMVC × ReturnValue

前言

1. 展示springMVC重定向或跳转的五种解决方案
2. 测试springMVC的Servlet的返回值。（示例中的HelloController的返回值）
3. 关键词
   1. Servlet
   2. 返回值
   3. forward，转发
   4. redirect，重定向
   5. mv，ModelAndView，整合了Model和View
   6. 然后呢？测试返回值有什么用途？是可以做重定向或跳转页面。所以？所以本示例是展示springMVC重定向或跳转的五种解决方案。

关系

extend springMVC × Model&ModelMap

arr={
POM.xml,
WEB.xml,
HelloController.java,
springMVC.xml,
successHTML.html,
index.jsp,
success.jsp
};

super.get(arr);

@Override(class)
HelloController.java;

客户端

value={
returnString,
returnForward,
returnRedirect,
returnVoid,
void,
mv
}

http://localhost:8080/value

HelloController.java

//关键词：
//forward，redirect的格式，就是一个键值对。
//key是forward或redirect，jsp的项目路径是value。
//当然，这些返回字符都是字符串。

		//返回普通字符（jsp的名称）进行转发
    @RequestMapping("/returnString")
    public String goNormalReturn(){
        System.out.println("returnString");
        return "success";
    }

    //返回返回字符（forward）进行转发
    //"forward:"+"JSP的项目路径"
    @RequestMapping("/returnForward")
    public String goForwardReturn(){
        System.out.println("forward");
        return "forward:/pages/success.jsp";
    }

    //返回重定向字符进行重定向
    //"redirect:"+"JSP的项目路径"
    @RequestMapping("/returnRedirect")
    public String goRedirect(){
        System.out.println("redirect");
        return "redirect:/pages/success.jsp";
    }


    //无返回，自行使用request或response进行转发或重定向
    //这和Servlet有没区别
    //request.getRequestDispatcher("jsp的项目路径").forward(本方法的request,本方法的response);
    @RequestMapping("/returnVoid")
    public void goVoid(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //转发
        //request.getRequestDispatcher("/pages/success.jsp").forward(request,response);
        //重定向
        System.out.println("void");
        response.sendRedirect("/pages/success.jsp");
    }

    //返回ModelAndView，进行转发
    //ModelAndView顾名思义，Model和View的混合体。
    //mv.addObject(key,value);
    //mv.setViewName("jsp的名称");
    @RequestMapping("/mv")
    public ModelAndView goMV(){
        ModelAndView mv =new ModelAndView();
        mv.addObject("cn","china");
        mv.setViewName("index");
        System.out.println("ModelAndView");
        return mv;
    }

springMVC × ResponseBody × RequestBody

前言

1. 展示基于SpringMVC&HTML的前后端交互
2. 关键词
   1. Json
   2. ResponseBody
   3. RequestBody
   4. Ajax
   5. 基于ResponseBody和RequestBody的Json对象自动封装。关于Ajax有个很重要的点，详见requestAjax.html。
   6. 用Pojo.Account类封装html通过Ajax发送的Json数据。据此，Account也可称为Json对象。需要注意的是，Pojo.Account的属性必须吻合Json数据的字段，才能自动封装从前端请求的Json数据进去。
   7. 还有一个很重要的点，那就是这个示例是基于SpringMVC和HTML的。之前几个点是基于SpringMVC和JSP的。往结构方面说，那就意味着，这个示例是面向静态资源，之前的是面向动态资源的

关系

extend springMVC × ReturnValuez

arr={
POM.xml,
WEB.xml,
HelloController.java,
springMVC.xml,
successHTML.html,
index.jsp,
success.jsp
};

HTML requestAjax.html =new HTML;

super.get(arr);

@Override(class)
HelloController.java;

客户端

http://localhost:8080/pages/requestAjax.html

POM.xml

        


				
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            
            <artifactId>jackson-coreartifactId>
            <version>2.9.5version>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            
            <artifactId>jackson-annotationsartifactId>
            <version>2.9.5version>
        dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.coregroupId>
            
            <artifactId>jackson-databindartifactId>
            <version>2.9.5version>
        dependency>

requestAjax.html

<script src="/js/jquery-3.3.1.min.js">script>

<script>
    $(function(){
        $("#ajaxPost").click(function(){
            $.ajax({
                // 请求类型，这里必须为post
                type : "post",
                // 请求地址
              	// 在SpringMVC示例中，必须带“/”，不然报错
                url : "/responseBodyJson",
                // 发送给后台的ajax数据
              	// 花括号外必须要单引号。这是标准Json格式。
                data:'{"id":100,"name":"jack","money":9.9}',
                // 后台返回的数据格式
                dataType:"json",
                // 请求格式与编码
              	// 这就是第4点提到的，很重要的点。这句请求格式与编码必须写，
              	// 不然@RequestBody获取的数据是UTF8码，未转成汉字的。
                contentType:"application/json;charset=utf-8",

                success : function(jsn){
                    alert("jsn="+jsn+"; jsn.id="+jsn.id+"; jsn.name="+jsn.name+"; jsn.money="+jsn.money);
                }
            });
        });
    });
script>

<h2>RequestBody获取请求JSON格式数据 & ResponseBody自动把对象转json并响应h2>
<button id="ajaxPost">测试ajax请求json与响应jsonbutton>

HelloController.java

    @RequestMapping("/responseBodyJson")
    @ResponseBody
		//自动拆箱Json对象，分解成Json数据，响应前端
		//放到返回值或者方法头上
    public Account responseBodyJson
    (
      
      @RequestBody//将Json数据，自动封装成所注解的类
      Account account//使其成为Json对象
      
      ){
        System.out.println("前端的数据"+account);
        account.setId(666);
        account.setName("xiaoAI");
        account.setMoney(999d);
        return account;
    }

Account.java

Json对象

public class Account {
    private Integer id ;
    private String name;
    private Double money;
……
//普通的JavaBean对象
}

##springMVC × ExceptionHandler

前言

1. 展示SpringMVC统一异常管理器。
2. 本示例并不是唯一解决方案，但是老师最推荐的解决方案。由于时间关系，不一一列举了。
3. 关键点：
   1. @ControllerAdvice；注解在类名上
   2. @ExceptionHandler；注解在方法上，参数是具体异常.class
   3. SpringMVC统一异常管理器是Spring组件，由IOC容器管理。所以必须要被bean标签配置，或者被包扫描的范围内。
   4. 以上两点是最重要的。

关系

extend springMVC × ResponseBody × RequestBody

arr={
POM.xml,
WEB.xml,
HelloController.java,
springMVC.xml,
successHTML.html,
requestAjax.html,
index.jsp,
success.jsp
};

JSP error.jsp =new JSP;
JSP error2.jsp =new JSP;

super.get(arr);

@Override(class)
HelloController.java;

客户端

http://localhost:3306/goError

SpringMVC.xml

<context:component-san base-package="cn.ningbaiyu.Controller"/>

HelloController.java

//路径：Controller\helloController.java

@RequestMapping("/goError")
public String goError(){
  //会出现ArithmeticException异常
  int i = 10 / 0;
  //然后不会跳转success.jsp
  return "success";
}

MyExceptionHandler.java

//路径：Controller\exception\MyExceptionHandler.java

//需要注意的是，只要是属于Spring IOC容器的注解。
//1. 都要处于被包扫描范围内
//2. 或者在XML配置文件中被bean标签配置。
@ControllerAdvice
public class MyExceptionHandler {
  
  //这个是SpringMVC统一异常处理器
  //只要发生异常，都会被这个处理抓获
  
  	//需要声明哪种异常
    @ExceptionHandler(NullPointerException.class)
  	//需要注入超级父类作为形参
    public String handlerError(Exception e){
      	//需要交给某个页面显示
        return "error";
      	当然，除此之外还可以做其他操作。
    }
  
    @ExceptionHandler(ArithmeticException.class)
    public String handlerError2(Exception e){
        return "error2";
    }

    @ExceptionHandler(Exception.class)
    public String handlerError3(Exception e){
        return "error";
    }
  
/*  
  error.jsp{
    error!!!
  }
  
  error2.jsp{
    error2!!!
  }
  */
}

springMVC × Restful × HiddenHttpMethodFilter

前言

1. 基于Restful的简写方案。
2. 关键词
   1. Restful是简写一种风格。具体实现跟黑马旅游网的BaseServlet很像。就是前端提交隐藏组件，后端识别组件中的属性，如果该属性等同于后端模块的方法名，那就执行该方法。
   2. HiddenHttpMethodFilter是过滤器，配置在WEB.xml
   3. post，增加/查询
   4. put，修改
   5. delect，DELETE
   6. get，查询

关系

extend springMVC × ResponseBody × RequestBody

arr={
POM.xml,
WEB.xml,
HelloController.java,
springMVC.xml,
successHTML.html,
requestAjax.html,
index.jsp,
success.jsp
};

HTML restful.html =new HTML

super.get(arr);

@Override(class)
HelloController.java;

客户端

@restful.html

WEB.xml

	
	
	<filter>
		<filter-name>hiddenHttpMethodFilterfilter-name>
		<filter-class>org.springframework.web.filter.HiddenHttpMethodFilterfilter-class>
	filter>
	
	<filter-mapping>
		<filter-name>hiddenHttpMethodFilterfilter-name>
		
		<url-pattern>/*url-pattern>
	filter-mapping>

restful.html

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>restful风格title>
head>
<body>
  
  



<form action="/user" method="post">
  	
  	
  	
  	
		
    <input type="hidden" name="_method" value="post">
    <input type="submit" value="增加">
form>


<form action="/user" method="post">
    <input type="hidden" name="_method" value="put">
    <input type="submit" value="修改">
form>




<form action="/user/10" method="post">
    <input type="hidden" name="_method" value="delete">
    <input type="submit" value="删除">
form>

<form action="/user/666/eric" method="post">
    <input type="hidden" name="_method" value="get">
    <input type="submit" value="查询">
form>
  
  
body>
html>

HelloController.java

  

		//这是基于HiddenHttpMethodFiller的指定访问域名
		//meth=RequestMethod.POST其实意思就是前端提交表单中的，隐藏标签的，
		//value属性是”post“
		@RequestMapping(method = RequestMethod.POST)
    public String add(){
        System.out.println("增加");
        return "success";
    }

    @RequestMapping(method = RequestMethod.PUT)
    @ResponseBody
		//由于前端并不识别PUT，所以只能用ResponseBody返回PUT。我忘了具体原因。
		//这么说，就只能死记硬背了？
    public String update(){
        System.out.println("修改");
        return "success";
    }
    @RequestMapping(value ="/{id}",method = RequestMethod.DELETE)
    @ResponseBody
    public String delete(@PathVariable("id") Integer id){
        System.out.println("删除");
        System.out.println("id = " + id);
        return "success";
    }
		//value="/{id}/{name}"，那时候我没有听课，我就觉得这是声明给Spring知道，
		//我要前端传过来的哪几个属性，以及我这边要用什么参数来接。
    @RequestMapping(value="/{id}/{name}",method = RequestMethod.GET)
		//@PathVariable("name") String name
		//PathVariable翻译过来是路径变量，括号中的参数，是上方@RequestMapping的Value的
		//参数。这两者是对应的。注解的String name，就真正意味着用这个参数封装。
    public String find(@PathVariable("name") String name,@PathVariable("id") Integer id){
    //如果前端的请求路径是“/url?id=10”，这就意味着得用@RequestParam("id")的方式
    //来注解方法的参数
   	
        System.out.println("查询");
        System.out.println("id + \"\" +name = " + id + "," +name);
        return "success";
    }

SSM × Annotation & XML

前言

1. 三大框架整合示例
2. 半注解半XML的整合方案

Spring

Mybatis

SpringMVC

(Basic)SSM × Annotation & XML × Module

前言

1. SaaSExport，三大框架整合示例
2. 使用半注解半XML的整合方案
3. 基于Maven实现模块化。
4. 各个模块的关键点在各自的前言中。

parentProject

POM.xml

Spring

Mybatis

SpringMVC

前言

1. 关键点
   1. 三大基本组件
      1. 类型转换
      2. 异常处理
      3. 编码过滤器