Spring、SpringMVC、Mybatis等框架知识点整合（ssm）

spring中得ioc di区别，以及对象的四种初始化方式，注解配置中常用的注解

aop中基本概念连接点，切入点，通知，切面等，以及aop的表达式编写

1.spring中的ioc/di的区别：

DI和IOC本质上没有区别，它们都是指Spring来创建、管理、初始化、销毁、控制Java类。只是它们站在不同的角度来描述关于对象的使用。 IOC：主要体现在对象的创建、控制、销毁等交给Spring容器。 DI：主要体现在Bean之间的使用（service使用dao），主要是依赖管理方向。

2.对象的四种初始化方式：（bean的实例化四种方式）
无参数构造方法（开发最常用）：编写bean类：类中如果没有书写任何的构造方法，那么就会有默认的空参数的构造方法*
静态工厂方法：在一个类中书写静态的方法，这个方法返回某个Bean的对象（在方法中创建Bean的对象）。
实例工厂方法：在类中提供的非静态的方法，这个方法中返回需要获取的Bean对象。
FactoryBean方式(Spring的底层使用比较多),FactoryBean是Spring提供的接口，专门用于对bean进行初始化操作的。

如果bean需要使用这种方式进行初始化，那么需要定义类实现这个接口，在实现类中复写getObject的方法。

3.注解配置中常的的注解：
JavaEE项目基本都是分为web层、service层、dao层。而每层的类都需要交给Spring容器管理。每个类都可以使用@Component注解。
但是这样就不容易分清楚当前注解的这个bean属于哪层，因此@Component注解有三个衍生的注解：
@Component注解 ： 任何一个Java类都可以使用这个注解，只要被它标注，Spring就会以bean的方式管理这个类。
@Controller注解 ： 主要用于标注web层的类（比如LoginServlet、LoginController等）
@Service注解：主要标注service层的类（比如：UserService等）
@Repository注解：主要标注dao层的类（比如：UserDao等）
Spring3.0后，提供 @Value注解，可以完成简单数据的注入。Value注解可以添加在成员变量或者对应的setXxx方法上。
@Autowired 是根据对应的属性的类型找到对应的bean进行注入
@Qualifier 可以指定需要注入的bean的id值，或者是@Component定义的名称。
使用Resource注解注入复杂类型数据：@Resource
使用 @PostConstruct 注解， 标明初始化方法 —相当于在xml的bean标签中使用 init-method 指定初始化方法
使用 @PreDestroy 注解， 标明销毁方法 ----相当于在xml的bean标签中使用 destroy-method 指定对象销毁方
通过@Scope注解，指定Bean的作用域（默认是 singleton 单例）。@Scope**（“prototype”）多列
**@RunWith(SpringJUnit4ClassRunner.class)?*表示当前使用的类要使用spring集成junit测试
@ContextConfiguration(“classpath:spring01.xml”):指定加载spring的核心配置文件
**@Transactional:**事务控制当前方法或当前类中的所有方法。

4.aop中基本概念连接点，切入点，通知，切面等：

什么是AOP？ AOP (Aspect Oriented Programing) 称为：面向切面编程，它是一种编程思想。
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码的编写方式（性能监视、事务管理、安全检查、缓存,日志记录等）。

joinpoint（连接点）：指那些被拦截到的点。在spring中指的可以被代理（增强）的方法。
pointcut（切入点）：对哪些连接点进行拦截的定义。在Spring中指的真正需要被代理（增强）的方法。
advice（通知/增强）：指拦截到连接点之后要做的事情。真正增强的那些代码（逻辑）。
通知/增强分为：
	前置通知，后置通知，异常通知，最终通知，环绕通知。
aspect（切面）：是切入点和通知/增强的结合过程。

before：前置通知，在被增强的方法执行之前运行的增强逻辑。
@Before("execution(* com..*.*(..))")
afterReturning：后置通知，在被增强的方法执行之后运行的增强逻辑。
@AfterReturning("execution(* com.spring.service.UserService.addUser())")
afterThrowing：异常通知，在出现异常的时候需要增强的逻辑。
around：环绕通知，在方法运行之前和之后都会执行的逻辑。
@Around("execution(* com.spring.service.UserService.addUser())")
after：最终通知，类似于final，不管怎么样都会执行的通知。
@After("execution(* com.spring.service.UserService.addUser())")

5.aop的表达式编写
1、bean(bean Id/bean name)
例如 bean(customerService) 增强customerService的bean中所有方法
<aop:pointcut expression=“bean(userDao)” id=“ponitcut”/>
2、execution(<访问修饰符>?<返回类型>空格<方法名>(<参数>)<异常>?)
例如：
execution(* com.neuedu.service.CustomerServiceImpl.(…)) 增强bean对象所有方法
execution( com.neuedu.service….(…)) 增强service包和子包所有bean所有方法
提示：最灵活的
<aop:pointcut expression="execution(* com.neuedu.dao.UserDao.(…))" id=“ponitcut”/>
3、within(包.类)
例如： within(com.neuedu.service…) 增强service包和子包所有bean“所有方法 ”
<aop:pointcut expression=“within(com.neuedu.dao.UserDao)” id=“ponitcut”/>
4、this(完整类型)/target(完整类型)
this对某一个类-（代理对象有效），target对代理对象无效(只对目标对象有效)
例如： this(com.neuedu.service.CustomerServiceImpl) 增强类型所有方法（对代理对象有效）
<aop:pointcut expression=“this(com.neuedu.dao.UserDao)” id=“ponitcut”/>

Mybatis中得代理模式如何使用和细节，接口中得方法和mapper使用，不用通用mapper完成表数据插入

1.mybatis中的代理模式如何使用：
要使用mybatis的动态代理，Mapper配置文件中的namespace的定义就不能随便书写，namespace必须为dao接口的全路径（也就是接口的所在的包名）。
使用SqlSession中的getMapper方法得到代理类。
将上面对用户的CRUD操作全部抽取成接口，然后使用mybatis的代理方式完成对用户的CRUD操作。
1.接口的抽取；
2.mapper文件编写；
3.测试代码

2.代理的细节：
使用mapper接口进行代理完成数据库操作，使用非常简单和方便，官方也推荐使用。
但使用mapper接口必须满足下面的几个条件：
1、mapper文件中的namespace必须被代理的接口所在的包名路径一致。
2、被代理接口中的方法名必须是mapper文件中书写的每个sql标签的id一致
3、被代理接口中的方法参数尽量和对应的标签中的paramterType一致（当然这个输入参数也可以省略，让框架自己根据参数检测也可以）。
4、被代理接口中的方法的输出参数类型必须和对应的标签中的resultType一致。

3.接口中得方法和mapper使用：

public interface IUserDao {
    //  添加用户
    public void addUser(User user);
	}
	---------------------------
	<mapper namespace="com.neuedu.dao.IUserDao">
    <!--
        在每个mapper的sql标签上的id属性，必须是接口中对应的方法名
    -->
    <insert id="addUser" parameterType="com.neuedu.pojo.User">
        insert into tb_user(user_name , name , password) values (#{username} , #{name} , #{password})
    </insert>
	</mapper>
-------------------------
public class UserTest {
private SqlSessionFactory factory;
@Before
public void init()throws  Exception{
    //1、获取配置文件
    InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
    factory = new SqlSessionFactoryBuilder().build(in);
}

//  测试添加用户
@Test
public void addUser()throws Exception{
    //  获取到数据库的连接对象
    SqlSession sqlSession = factory.openSession(true);
    User user = new User();
    user.setName("郑成峰");
    user.setUsername("zcf");
    user.setPassword("zcf");

    //  获取指定的接口的代理对象
    IUserDao userDao = sqlSession.getMapper(IUserDao.class);
    userDao.addUser(user);
    //sqlSession.insert("com.neuedu.dao.IUserDao.addUser",user);
}

4.不用通用mapper完成表数据插入:
mybatis注解开发主要使用的注解有：
@Select：完成查询sql语句的编写
@Update：完成修改的SQL语句编写
@Delete：完成删除的SQL语句编写
@Insert：完成插入的SQL语句编写

public interface IUserDao(){
		@select("select * from tb_user where id=#{id}")
		public User findUserById(integer id);
	}
	------------------------------
	public class UserTest {
    private SqlSessionFactory factory;

    @Before
    public void init() throws Exception {
        //1、获取配置文件
        InputStream in = Resources.getResourceAsStream("mybatis-config.xml");
        factory = new SqlSessionFactoryBuilder().build(in);
    }

    @Test
    public void testFindUserById(){
        SqlSession session = factory.openSession(true);
        IUserDao dao = session.getMapper(IUserDao.class);
        User user = dao.findUserById(1);
        System.out.println(user);
    }
}

注意：
使用mybatis的注解开发，千万不要再书写Mapper文件，否则会报错。
Mybatis在进行开发的时候，要么使用xml配置开发，要么使用注解开发，两者不能共存

5.Mybatis的缓存：
Mybatis的一级缓存是SQLSession级别的，不能禁用；
Mybatis的二级缓存是Mapper级别的，可以禁用

Springmvc的工作原理，设置请求路径的注解和使用，请求和响应是json格式分别使用哪些注解完成。以及springmvc如何定义方法获取客户端提交的用户名密码等参数。

1.Springmvc的工作原理:
SpringMVC的工作核心是DispatcherServlet，所有的请求和响应都需要经过DispatcherServlet处理。
也就说请求只要能进入到DispatcherServlet中，那么接下来的操作就是SpringMVC的事情了。
SpringMVC主要工作在web层，用于处理用户的请求和响应，其主要是代替繁琐的Servlet程序。
SpringMVC的工作原理：
1、用户发起请求会统一进入配置在项目的web.xml文件中的DispatcherServlet（前提请求的路径必须符合servlet-mapping中的url-pattern的配置）。
2、进入到DispatcherServlet（SpringMVC的核心处理类）之后，首先会将请求分发给HandlerMapping（处理器映射器），
这个处理器映射器会分析出具体的执行链（HandlerExecutorChain包含不同的Handler对象和拦截器集合）。并将执行链返回给DispatcherServlet。
3、DispatcherServlet拿到执行链之后，会找HandlerAdapter（处理器适配器），适配器会去执行每个不同的Handler模型（实现了Controller接口的那个类）对象，
Handler模型对象执行完成之后返回ModelAndView对象（模型视图对象，其中包含view：视图名称，model模型数据），
HandlerAdapter获取到ModelAndView之后，将模型视图对象返回给DispatcherServlet。
4、DispatcherServlet继续去查找ViewResolve（视图解析器），分析出具体需要真正执行的视图对象，并将要执行的视图对象返回给DispatcherServlet。
5、DispatcherServlet找到View（视图）进行渲染，最后DispatcherServlet给用户产生对应的响应数据。

2.设置请求路径的注解和使用:
使用注解开发SpringMVC，需要使用到@RequestMapping注解来书写具体的请求路径。
@RequestMapping可以书写在类上，也可以书写在方法上，类上的可以省略。

// 添加注解
	@Controller // 将这个类交给spring管理
	/*
	 * 使用@RequestMapping注解来标注请求的路径映射
	 * 	name属性：给当前的Controller起名字
	 *  value属性等价于path属性：是配置外界的访问路径
	 *  
	 */
	@RequestMapping(name="demo" , value="demo")
	public class DemoController {
		
		@RequestMapping(path="abc")
		public ModelAndView demo(){
			System.out.println("abc");
			return null;
		}
	}

注意：当在类和方法都添加了@RequestMapping注解之后，浏览器的请求路径必须是：http://ip地址:端口号/项目名/类上的路径/方法上的路径.扩展名

3.请求和响应是json格式分别使用哪些注解完成:
public void demo(@RequsetBody User user){sout…}
json转pojo
需要接受客户端提交的json格式数据，并将json数据封装到pojo上，仅仅只需要在方法上添加@RequsetBody注解即可。
注意：使用@RequestBody注解，必须添加jackson的jar包

@Controller
public class Demo6Controller {

	/**
	 * 需要通过SpringMVC将某个对象（pojo、集合、数组等）
	 * 最终以json格式返回给客户端，在方法的返回值类型上直接书写需要返回的这个对象即可
	 * 然后在方法上再加上@ResponseBody
	 */
	@RequestMapping("json2")
	@ResponseBody  // 告诉SpringMVC，需要将返回的对象转成json格式的数据
	public User demo1(){
		User user = new User();
		user.setAge(23);
		user.setBirthday(new Date());
		user.setPassword("abc");
		user.setSex("女");
		user.setUsername("孙波");
		return user;
	}
}

**

响应json数据

**
在实际开发中经常需要web层返回json格式的数据，SpringMVC提供了一种更加便捷的输出json格式的数据，
只要在方法上添加注解@ResponseBody。

4.springmvc如何定义方法获取客户端提交的用户名密码等参数:

1、直接把表单的参数写在Controller相应的方法的形参中，适用于get方式提交，不适用于post方式提交。

@RequestMapping("/addUser1")
    public String addUser1(String username,String password) {
        System.out.println("username is:"+username);
        System.out.println("password is:"+password);
        return "demo/index";
    }

2、通过HttpServletRequest接收，post方式和get方式都可以。

@RequestMapping("/addUser2")
    public String addUser2(HttpServletRequest request) {
        String username=request.getParameter("username");
        String password=request.getParameter("password");
        System.out.println("username is:"+username);
        System.out.println("password is:"+password);
        return "demo/index";
    }

3、通过一个bean来接收,post方式和get方式都可以。
(1)建立一个和表单中参数对应的bean

public class UserModel {
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

(2)用这个bean来封装接收的参数

@RequestMapping("/addUser3")
    public String addUser3(UserModel user) {
        System.out.println("username is:"+user.getUsername());
        System.out.println("password is:"+user.getPassword());
        return "demo/index";
    }

4、get请求通过@PathVariable获取路径中的参数

@RequestMapping(value="/addUser4/{username}/{password}",method=RequestMethod.GET)
public String addUser4(@PathVariable String username,@PathVariable String password) {
        System.out.println("username is:"+username);
        System.out.println("password is:"+password);
        return "demo/index";
    }

5、用注解@RequestParam绑定请求参数到方法入参

@RequestMapping(value="/addUser6",method=RequestMethod.GET)
    public String addUser6(@RequestParam("username") String username,@RequestParam("password") String password) {
        System.out.println("username is:"+username);
        System.out.println("password is:"+password);
        return "demo/index";
    }

5.Springboot的核心启动类是什么:

	@SpringBootApplication  // SpringBoot的核心启动注解
public class SpringBootStarter {
    public static void main(String[] args) {
        // 使用SpringBoot的核心类来启动整个项目
        SpringApplication.run(SpringBootStarter.class , args);
    }
}