1. 第一天
问题：怎样的程序是一个优秀的程序
可维护性好，可扩展性好，性能优秀
问题：业界对象提供什么的概念
高内聚，低耦合，也就是尽量使代码对应的功能写在对应的模块，并且尽量减少类与类之间的关系，使得修改起来比较方便，不会影响其它代码，也就是更好的做到可维护性与可扩展性使之成为一个优秀的程序。
问题：Ioc解决了什么问题
loc实现了程序的解耦，解决了耦合度问题。
问题：Spring的定义
spring是一个轻量级的一站式java EE的开发框架
问题：Spring的作用
基于spring的定义，轻量级和一站式，就可以看出，它既可以作为一个完整的框架完成表示层，服务层，持久层实现一整个程序的所有开发这就是它所体现的一站式同时
作为轻量级，它还能用于整合其它框架。
问题：Spring的入门示例步骤
要求：将步骤列好 （每个步骤需要提示对应的代码截图）
1.导入包
从下载好的spring框架包里的libs文件夹下找到如下几个必须的包进行导入
2.配置xml的约束文件，使其自动生成
需要在eclipse-windows-preference-XML-XML Catalog中添加一个新的约束，直接add，然后在
spring源码包中找到xsd约束文件进行添加配置
3.创建容器到对象
1.创建类
package cn.gzsxt.service;
public class HelloWorldService {
public void say(){
System.out.println("--你好世界！--");
}
}
2配置xml
先直接创建一个xml文件，并且选中beans基于约束文件配置让它自动生成相关代码
配置容器
<bean name="helloWorldService" class="cn.gzsxt.service.HelloWorldService"></bean>
1.3配置一个测试类
package cn.gzsxt.test;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.gzsxt.service.HelloWorldService;
public class HelloWorldServiceTest {
@Test
public void say(){
//创建一个ApplicationContext对象
ClassPathXmlApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");
HelloWorldService helloWorldService = context.getBean("helloWorldService", HelloWorldService.class);
//调用方法
helloWorldService.say();
//结束程序，可以关闭容器
context.close();
}
}
注意事项：配置的location要和spring.schemas保持一致，否则会出现连不上网的情况·
问题：Ioc的入门示例步骤（要求同上）
建议：画一下Ioc的流程图！！！
要求：将步骤列好 （每个步骤需要提示对应的代码截图）
注意事项：
问题：对Properties的支持（代码）
1.2. 第二天
问题：为什么需要通过注解配置Spring。
因为当做项目时需要创建的类比较多哦，而通过xml配置的话，每一个类都需要配置一个，就会比较繁琐，而通过注解的话就比较简单，可以全局搜索创建
问题：注解配置，注解对象的配置文件的标签是什么。（尽量做到）
<context:component-scan base-package="要搜索的目录路径"></context:component-scan>
问题：使用纯注解修改第一天Ioc的代码（要求）
示例的目的是什么？
要求：将步骤列好 （每个步骤需要提示对应的代码截图）
1.创建一个配置类，并且用注解标签@configuration给这个类声明为注解类，并且用@ComponentScan("要扫描的包名路径")给它指明扫描路径
2.因为已经把xml文件改成了注解声明的类，所以我们的测试类代码所谓的容器就不再是ClassPathXmlApplicationContext
而是通过AnnotationCongigApplicationContext这个容器来调用配置类。
注意事项：
1.3. 第三天
问题:AOP是什么
AOP是一种面向切面编程的技术
问题：为什么需要使用AOP
AOP可以使一些部分功能进行分离，能更好的降低程序的耦合性，提升程序的可用性
问题：AOP的入门示例（XML）
1先导入需要的包
2.创建一个aop的切面类
package cn.gzsxt.aop;
import org.aspectj.lang.ProceedingJoinPoint;
public class StudentAOP {
public void before() {
System.out.println("方法执行之前");
}
public void after() {
System.out.println("方法执行之后");
}
}
3.创建一个功能类的实现方法
package cn.gzsxt.service.impl;
import java.util.Map;
import org.springframework.stereotype.Service；
import cn.gzsxt.service.StudentService;
@Service
public class StudentServiceImpl implements StudentService{
@Override
public void login(Map<String, Object> entity) {
System.out.println("学生登录"+entity);
}
}
4.配置xml文件
配置一个类
<bean name="studentService" class="cn.gzsxt.service.impl.StudentServiceImpl"></bean>
创建aop切面
<bean name="aop" class="cn.gzsxt.aop.StudentAOP"></bean>
配置aop
<aop:config>
<aop:pointcut expression="execution(public void cn.gzsxt.service.impl.*.*(..))" id="public_pointcut"/>
配置切面
<aop:aspect id="aop" ref="aop">
配置了两个通知
方法执行前
<aop:before method="before" pointcut-ref="public_pointcut"/>
方法执行后
<aop:after method="after" pointcut-ref="public_pointcut"/>
5.创建一个测试类
package cn.gzsxt.test;
import java.util.HashMap;
import java.util.Map;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.gzsxt.service.StudentService;
import cn.gzsxt.service.impl.StudentServiceImpl;
public class ApplicationContextTest {
public static void main(String[] args) {
//通过配置文件创建容器:
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
//通过容器来获取对象
StudentService studentService = context.getBean("studentService", StudentService.class);
//调用对象的方法
Map<String, Object> entity = new HashMap<>();
entity.put("name", "张三");
studentService.login(entity);
//关闭容器
context.close();
}
问题：AOP的入门示例（纯注解）
基于xml配置的前提下：
1.把配置类那些配置类什么的全部取消改为全局搜索路径创建容器对象
<context:component-scan base-package="cn.gzsxt" />
aop也改为使用自动代理
<aop:aspectj-autoproxy />
2.然后在切面类类名前加上@component和@Aspect声明这是一个切面类，并且在切面方法前面加入对应的注释
@Before(value="execution(* cn.gzsxt.service.impl.*.*(..))") 添加到方法之前
@After(value="execution(* cn.gzsxt.service.impl.*.*(..))") 添加到方法之后
@Around(value="execution(* cn.gzsxt.service.impl.*.*(..))") 添加到方法前后
@AfterReturning(value="execution(* cn.gzsxt.service.impl.*.*(..))") 方法正常执行之后拦截
@AfterThrowing(value="execution(* cn.gzsxt.service.impl.*.*(..))") 方法异常之后进行拦截
value值中execution括号里为需要加入切面的类的路径
【建议】问题：Ioc的实现步骤以及代码
1.4. 第四天
1.问题：什么是事务代理
在进行数据的操作时，大部分情况是两个对象同时执行莫一个功能，要么都成功要么都失败，
不然会使存储的数据出现bug，这种操作，我们称之为失误代理
2.问题：什么是事务的隔离级别
就是指同时发生多线程操作的时候每个线程执行的事务之间的关系就是所谓的隔离级别
ISOLATION_DEFAULT：默认隔离级别
ISOLATION_READ_UNCOMMITTED：可以读未另一个事务提交的数据
ISOLATION_READ_COMMITTED ：只能读已提交的数据
ISOLATION_REPEATABLE_READ：是否读取其他事务提交修改后的数据
ISOLATION_SERIALIZABLE：是否读取其他提交增加后的数据
3.问题：什么是事务的传播行为
就是事务代理，将一个方法的事务对象传递到下一个方法的过程
4.问题：Spring JDBC 的示例（增删改查，配置事务）
1.首先导入所需要用到的包
2.配置xml文件
配置数据源
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
添加4个连接数据源必须的参数
<property name="driverClassName" value="org.gjt.mm.mysql.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/sms"></property>
<property name="username" value="root"></property>
<property name="password" value="555555"></property>
</bean>
获得JdbcTemplate操作对象
<bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
设置数据源
<property name="dataSource" ref="dataSource"></property>
</bean>
配置事务代理
<bean name="dataSource" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"></property>
</bean>
<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>
3.通过，@Autowired依赖注入注解，实现从dao层到controller的方法调用，方法里连接数据库直接使用配置好的操作对象先注入jdbcTemplate这个操作对象
jdbcTemplate.update可以使用增删改，jdbcTemplate.excute可以使用查询。
代码步骤
注意事项：
--列表Spring所有已经学习的使用标签，标识每个标签的作用
--列出Spring所有已经学习的注解，标识每个注解的作用
--列出Spring所有使用的API （类、接口），标识每个API要素的作用
2. SpringMVC
SpringMVC总结报告
问题：SpringMVC是什么
SpringMVC是spring框架内置的MVC的实现，跟MVC的功能是差不多的
问题：MVC是什么
MVC就是一种把代码分为模图-视图-控制器三层结构用来实现页面代码和后台代码分离的设计思想
问题：为什么使用SpringMVC
因为SpringMVC是spring框架自带的，虽然功能跟MVC差不多，但是它支持spring的一些组件功能，而MVC不一定支持
问题：入门示例（配置流程图，列步骤）
1.导入需要的包
2.在web.xml中配置一个核心控制器，对所有请求进行拦截，使之请求与方法一一对应
<servlet>
<servlet-name>DispatcherServlet</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>配置参数使其指定spring-mvc.xml这个配置文件
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring-mvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>DispatcherServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
3.配置一个xml的配置文件，用来指定请求路径与对象
<bean name="/say.do" class="cn.gzsxt.controller.HelloCotroller"></bean>
4.控制层controller
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.multiaction.MultiActionController;
//基于配置文件配置的controller必须要实现或继承controller的接口以及它的子类
public class HelloCotroller extends MultiActionController{
public ModelAndView say(HttpServletRequest request, HttpServletResponse response) {
System.out.println("你好世界");
ModelAndView modelAndView = new ModelAndView();
modelAndView.setViewName("/hello.jsp");
return modelAndView;
}
}
问题：什么是自动数据绑定
不需要任何数据绑定的注解直接将表单参数绑定到我们的执行方法的参数上
问题：什么是数据强制绑定
强制绑定就是有一些数据它不存在与表单中，当它传过来的时候不会自动绑定，这个时候我们就需要通过一系列的注解标签来进行强制绑定了
问题：数据绑定时，有哪些支持的内置对象
HttpServletRequest，HttpServletResponse，HttpSession这三个都是内置对象
问题：对上传的支持配置步骤 （配置有哪些，为什么）
问题：对JSON支持的配置步骤
1.导入需要的相关包
2.配置文件中加入实现对json支持的注解配置
<mvc:annotation-driven></mvc:annotation-driven>
问题：SpringMVC我们学习了哪些注解，分别代表什么含义！！！(重点)
@RestController 这个是一个用于声明是一个Rest风格接口的组件类。等同@Controller+@ResponseBody
--列出使用了哪些注解，并且说明每个注解的作用！！
--列出使用了哪些API，并且说明每个API的作用