首页  思维导图  详情

框架

2017-09-06 14:28:22   0  举报





仅支持查看

AI智能生成

Mybatis,Spring框架

作者其他创作

大纲/内容

Spring

两大核心

IOE控制反转，也叫依赖注入DI

所谓媒体“海选”和第三方中介机构在程序领域即是一个第三方的容器，它帮助完成类的初始化与装配工作，让开发者从这些底层实现类的实例化、依赖关系装配等工作中脱离出来，专注于更有意义的业务逻辑开发工作。这无疑是一件令人向往的事情，Spring就是这样的一个容器，它通过配置文件或注解描述类和类之间的依赖关系，自动完成类的初始化和依赖注入的工作。

ApplicationContext c = new ClassPathXmlApplicationContext("aopTryCatch.xml");         UserService  us =(UserService) c.getBean("userService");//这里是接口，如果一个类没有实现接口，那就写类名

三种注入方式

getter&setter方式注入

<bean id="hello" class = "bgs.Hello">         <property name="person">             <value>武松说：</value>         </property>         <property name="say">             <value>上山打老鼠</value>         </property>     </bean>     <bean id="helloo" class = "bgs.Hello">         <property name="person">             <value>梁爽说：</value>         </property>         <property name="say">             <value>我快热死了</value>         </property>     </bean>

public void hello(){         // 通过ClassPathXmlApplicationContext实例化Spring的上下文         ApplicationContext c = new ClassPathXmlApplicationContext("mySpring.xml");         // 通过ApplicationContext的getBean()方法，根据id来获取bean的实例         Hello bean = (Hello) c.getBean("hello");         System.out.println(bean.getPerson()+bean.getSay());         Hello bean2 = (Hello) c.getBean("helloo");         System.out.println(bean2.getPerson()+bean2.getSay());     }

构造函数注入

<bean id ="find" class="Dao.UserDaoImpl"></bean>     <bean id ="service" class="UserService.UserServiceImpl">         <constructor-arg ref="find" index="0"></constructor-arg> </bean> index="0"表示第一个形参，1表示第二个形参

ApplicationContext c = new ClassPathXmlApplicationContext("mySpring.xml");         UserService us = (UserService) c.getBean("service");         us.findUser();

实现类 private UserDao userDao;     public UserServiceImpl(){             }     public UserServiceImpl(UserDao userDao){         this.userDao = userDao;     } //方法     @Override     public void findUser(User user) {         userDao.findUser(user);     }

实现类 private UserDao userDao;     构造方法     public UserServiceImpl(){             }     public UserServiceImpl(UserDao userDao){         this.userDao = userDao;     } 调Dao层方法     @Override     public void findUser(User user) {         userDao.findUser1(user);             }

p命名空间注入

<bean id="userDao2" class="Dao.UserDaoImpl" p:user-ref="user"></bean>     <bean name="userimpl" class="UserService.UserServiceImpl" p:userDao-ref="userDao2">//p:属性名-ref=bean的id,需要setter方法              </bean>     <bean id ="user" class="pojo.User" p:id="1" p:username="凉爽" p:password="12345" p:email="292933@qq.com"></bean>

public void find1(){         ApplicationContext c = new ClassPathXmlApplicationContext("mySpring.xml");         UserService us = (UserService) c.getBean("userimpl");         User bean = (User) c.getBean("user");         us.findUser(bean);     }

xmlns:p="http://www.springframework.org/schema/p"

各种注入类型Demo

private String specialCharacter1;//特殊字符值1     private String specialCharacter2;//特殊字符值2     private User innerBean;//JavaBean类型     private List<String> list;//List类型     private String [] array;//数组类型     private Set<String> set;//Set类型     private Map<String,String> map;//Map类型     private Properties props;//Properties类型     private String emptyValue;//注入空字符串值     private String nullValue ="init value";//注入null值 //省略getter&setter public void showValue() {         System.out.println("特殊字符1：" + this.specialCharacter1);         System.out.println("特殊字符2：" + this.specialCharacter2);         System.out.println("内部Bean：" + this.innerBean.getUsername());         System.out.println("List属性：" + this.list);         for (int i = 0; i < array.length; i++) {             System.out.println("数组属性["+i+"]：" + this.array[i]);         }         System.out.println("Set属性：" + this.set);         System.out.println("Map属性：" + this.map);         System.out.println("Properties属性：" + this.props);         System.out.println("注入空字符串：[" + this.emptyValue + "]");         System.out.println("注入null值：" + this.nullValue);     }

<bean id="entity" class="kindofEntity.entity">                  <property name="specialCharacter1">             <value><![CDATA[P&$#G]]></value>         </property>                  <property name="specialCharacter2">             <value>P&gt;G</value>         </property>                           <property name="innerBean">             <bean class="pojo.User">                 <property name="username">                     <value>Mr.Inner</value>                 </property>             </bean>         </property>                           <property name="list">             <list>                 <value>足球</value>                 <value>篮球</value>             </list>         </property>                           <property name="array">             <array>                              <value>足球</value>                 <value>篮球</value>                 <value>乒乓球</value>             </array>         </property>                  <property name="set">             <set>                                  <value>足球</value>                 <value>篮球</value>             </set>         </property>                  <property name="map">             <map>                                  <entry>                                          <key>                         <value>football</value>                     </key>                     <value>足球</value>                 </entry>                                  <entry>                     <key>                         <value>basketball</value>                     </key>                     <value>篮球</value>                 </entry>             </map>         </property>                           <property name="props">             <props>                                  <prop key="driver">com.mysql.jdbc.Driver</prop>                 <prop key="url">jdbc:mysql://localhost:3306/0518</prop>             </props>         </property>                           <property name="emptyValue">             <value></value>         </property>                  <property name="nullValue"><null/></property>     </bean>

//控制台打印结果： 特殊字符1：P&$#G 特殊字符2：P>G 内部Bean：Mr.Inner List属性：[足球, 篮球] 数组属性[0]：足球 数组属性[1]：篮球 数组属性[2]：乒乓球 Set属性：[足球, 篮球] Map属性：{football=足球, basketball=篮球} Properties属性：{url=jdbc:mysql://localhost:3306/0518, driver=com.mysql.jdbc.Driver} 注入空字符串：[] 注入null值：null

注解

<ul><li>它可以充分利用 Java 的反射机制获取类结构信息，这些信息可以有效减少配置的工作。如使用 JPA 注释配置 ORM 映射时，我们就不需要指定 PO 的属性名、类型等信息，如果关系表字段和 PO 属性名、类型都一致，您甚至无需编写任务属性映射信息——因为这些信息都可以通过 Java 反射机制获取。</li><li>注释和 Java 代码位于一个文件中，而 XML 配置采用独立的配置文件，大多数配置信息在程序开发完成后都不会调整，如果配置信息和 Java 代码放在一起，有助于增强程序的内聚性。而采用独立的 XML 配置文件，程序员在编写一个功能时，往往需要在程序文件和配置文件中不停切换，这种思维上的不连贯会降低开发效率。</li></ul>

xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd"          <context:component-scan base-package="service,dao" />

/**  * 用户DAO类，实现UserDao接口，负责User类的持久化操作  */ @Repository("userDao") //<bean id="userDao" class="dao.impl.UserDaoImpl"></bean> public class UserDaoImpl implements UserDao {     public void save(User user) {         // 这里并未实现完整的数据库操作，仅为说明问题         System.out.println("保存用户信息到数据库");         System.out.println(user.getUsername());         System.out.println(user.getEmail());     }

@Service("service") public class UserServiceImpl implements UserService {     // 声明接口类型的引用，和具体实现类解耦合     @Autowired     // UserDao dao = (UserDao) ctx.getBean("userDao");     @Qualifier("userDao") //  @Resource(name="userDao")     private UserDao dao;     // dao 属性的setter访问器，会被Spring调用，实现设值注入，注解自动装配 //    public void setDao(UserDao dao) { //        this.dao = dao; //    }     public void addNewUser(User user) {         // 调用用户DAO的方法保存用户信息         dao.save(user);     } }

@Resource（JSR-250标准注解，推荐使用它来代替Spring专有的@Autowired注解） Spring 不但支持自己定义的@Autowired注解，还支持几个由JSR-250规范定义的注解，它们分别是@Resource、@PostConstruct以及@PreDestroy。 @Resource的作用相当于@Autowired，只不过@Autowired按byType自动注入，而@Resource默认按 byName自动注入罢了。@Resource有两个属性是比较重要的，分别是name和type，Spring将@Resource注解的name属性解析为bean的名字，而type属性则解析为bean的类型。所以如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既不指定name也不指定type属性，这时将通过反射机制使用byName自动注入策略。 @Resource装配顺序 1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常 2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到则抛出异常 3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常 4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配（见2）；如果没有匹配，则回退为一个原始类型（UserDao）进行匹配，如果匹配则自动装配； 1.6. @PostConstruct（JSR-250） 在方法上加上注解@PostConstruct，这个方法就会在Bean初始化之后被Spring容器执行（注：Bean初始化包括，实例化Bean，并装配Bean的属性（依赖注入））。

AOP

AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。 而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。   使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”   实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

使用场景

Authentication 权限 Caching 缓存 Context passing 内容传递 Error handling 错误处理 Lazy loading　懒加载 Debugging　　调试 logging, tracing, profiling and monitoring　记录跟踪　优化　校准 Performance optimization　性能优化 Persistence　　持久化 Resource pooling　资源池 Synchronization　同步 Transactions 事务

案例

<context:component-scan base-package="UserService,Dao,pojo"></context:component-scan>     <bean id="AopTryCatch" class="Aop.AopTryCatch"></bean>     <aop:config>         <aop:pointcut expression="execution(* UserService.UserServiceImpl.*User(..))" id="pointcut"/>         <aop:aspect ref="AopTryCatch">             <aop:before method="bef" pointcut-ref="pointcut"/>             <aop:after-returning method="afterReturning" pointcut-ref="pointcut" returning="result"/>             <aop:after-throwing method="afterThrowing" pointcut-ref="pointcut" throwing="e"/>             <aop:after method="after" pointcut-ref="pointcut" />         </aop:aspect>     </aop:config>

切面类

public void bef(JoinPoint jp){         System.out.println("这是前置增强");         System.out.println("jp.getTarget()"+jp.getTarget());         System.out.println("jp.getSignature().getName()"+jp.getSignature().getName());         System.out.println("jp.getSignature()"+jp.getSignature());         System.out.println("Arrays.toString(jp.getArgs())"+Arrays.toString(jp.getArgs()));         System.out.println("jp.getKind()"+jp.getKind());              }     public void afterReturning(Object result){         System.out.println("这是后置增强：afterReturning");         System.out.println("切面类取得的返回值"+result);     }     public void afterThrowing(Exception e){         System.out.println(e.getStackTrace());         System.out.println("这里是后置增强：afterThrowing");     }     public void after (){         System.out.println("这里是最终增强");     }

实现类

@Service("userService") public class UserServiceImpl implements UserService{     @Autowired     @Qualifier("saveUser")     private saveUser saveUser;//这个不用     @Autowired     @Qualifier("userDao")     private UserDao userDao;     @Override     public String findUser() {         userDao.findUser();         return "这里是findUser的返回值";     }

Aop注解

<context:component-scan base-package="UserService,Dao,pojo"></context:component-scan>     <bean class="Aop.AopZhujie"></bean>     <aop:aspectj-autoproxy />//自动扫描

@Aspect public class AopZhujie {     private static final Logger log= Logger.getLogger(AopZhujie.class);     @Pointcut("execution(* UserService.UserServiceImpl.find*(..))")     public void pointcut(){}          @Before("pointcut()")     public void before (JoinPoint jp){         log.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法。方法入参："+Arrays.toString(jp.getArgs()));     }     @AfterReturning(pointcut="pointcut()",returning = "returnValue")     public void afterRetruning (JoinPoint jp,Object returnValue){         log.info("调用"+jp.getTarget()+"的"+jp.getSignature().getName()+"方法。方法返回值："+returnValue);     }     @After("pointcut()")     public void after(){         System.out.println("这是最终增强");     }

Spring MVC

RequestMappingController：SpringMVC响应请求的几种方式

0911配置SpringMvc 继承Conttroller抽象类

Web.xml

<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-servlet.xml</param-value>     </init-param>     <load-on-startup>1</load-on-startup>   </servlet>   <servlet-mapping>     <servlet-name>springmvc</servlet-name>     <url-pattern>/</url-pattern>   </servlet-mapping>

继承Controller抽象类

public class IndexController extends AbstractController{     @Override     protected ModelAndView handleRequestInternal(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {         System.out.println("Hello,SpringMVC! from controller");         return new ModelAndView("Demo");     } }

XML

用注解配置Spring

Web.xml一样

@Controller @RequestMapping("/RequestMapping")//路径名为：工程名+RequestMapping+index，如果空值，则工程名+index public class IndexController extends AbstractController{     @Override     @RequestMapping("/index")     protected ModelAndView handleRequestInternal(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {         System.out.println("Hello,SpringMVC! from controller");         return new ModelAndView("Demo");     } }

xml

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"     xmlns:context="http://www.springframework.org/schema/context"     xmlns:p="http://www.springframework.org/schema/p"     xmlns:mvc="http://www.springframework.org/schema/mvc"     xsi:schemaLocation="http://www.springframework.org/schema/beans     http://www.springframework.org/schema/beans/spring-beans-3.2.xsd     http://www.springframework.org/schema/mvc     http://www.springframework.org/schema/mvc/spring-mvc.xsd     http://www.springframework.org/schema/context     http://www.springframework.org/schema/context/spring-context-3.2.xsd">                    <context:component-scan base-package="bgs.Controller"></context:component-scan>     <mvc:annotation-driven/>//将@Controller自动注册，上面是扫描，这里是实例     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">         <property name="prefix" value="/WEB-INF/jsp/"></property>         <property name="suffix" value=".jsp"></property>              </bean>      </beans>

0912下午用注解方式

用注解可以配置多个RequestMapping

@Controller @RequestMapping("RequestMapping") public class RequestMappingController {     //value属性执行映射路径或URL模板     //@RequestMapping(value="/welcome")如果只指定value属性时可以把value略去     @RequestMapping("/welcome")     //同时注解类与方法，需要先指定类的路径再指定方法的路径：http://localhost:8080/requestMapping/welcome     public String action1(Model model){         //在模型中添加属性message值，渲染页面时使用         model.addAttribute("message", "注解Spring MVC");         return "requestMapping";     }     @RequestMapping     public String action2(Model model){         //在模型中添加属性message值，渲染页面时使用         model.addAttribute("message","@RequestMapping为空，这是默认的方法");         return "requestMapping";     }          @RequestMapping(value="/action3",method={RequestMethod.POST,RequestMethod.GET})     public String action3(Model model){         model.addAttribute("message", "请求类型只能是post与get");         return "requestMapping";     }     @RequestMapping(value="/action4",consumes="text/html")     public String action4(Model model){         model.addAttribute("message","请求的提交内容类型（Context-Type）是text/html");         return "requestMapping";     }     @RequestMapping(value="/action5",params={"id=215","name!=abc"})     public String action5(Model model){         model.addAttribute("message","请求的参数必须包含id=215与name不等于abc");         return "requestMapping";     }

jsp <%@ page language="java" contentType="text/html; charset=UTF-8"     pageEncoding="UTF-8"%> <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> <title>Insert title here</title> </head> <body> <h1>${message}</h1> </body> </html>

0913Spring MVC通过实现接口Controller

public class InterfaceController implements Controller{     //处理请求且返回一个模型与视图对象     @Override     public ModelAndView handleRequest(HttpServletRequest arg0, HttpServletResponse arg1) throws Exception {         //返回一个模型视图，指定路径，指定模型的形成为message，值为一段字符串         return new ModelAndView("interface","message","Hello，我是通过实现接口定义");     } }

RequestController：取得form表单数据的几种方式

xml

同上     <context:component-scan base-package="bgs.Controller"></context:component-scan>     <mvc:annotation-driven/>     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">         <property name="prefix" value="/WEB-INF/jsp/"></property>         <property name="suffix" value=".jsp"></property>              </bean>

@Controller @RequestMapping("/request") public class RequestController {     @RequestMapping("/action1")     //方法得参数可以是任意基本数据类型     //如果方法参数名与http中请求的参数名称相同时会进行自动映射     //包装类型也一样，但如果参数中没有对应名称与类型的数据则会异常。     //基本数据类型不能为空，否则会出现400，如int id的值不能为空     public String action1(Model model,int id,String name,Integer age,String sex){         model.addAttribute("message", "id="+id+",name="+name+",age="+age);         return "request";     } }

@RequestMapping("/action2")     //除了基本数据类型，也可以自定义的数据类型，如一个自定义的pojo对象，     //Spring MVC会通过反射把其中的参数设置到对象中，转换类型     public String action2(Model model,User user){         model.addAttribute("message",user);         System.out.println(user.toString());         return "request";     }

如果出现乱码，可在Web.xml设置   <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("/action3")     //复杂数据类型     //复杂数据类型指的是一个自定义类型中还包含另外一个对象类型     public String action3(Model model,User user){         model.addAttribute("message",user+";"+user.getBill());         return "request";     }

<form action="/SpringMvc0911/request/action3" method="post"> id：<input type="text" name="id"> name：<input type="text" name="name"> age：<input type="text" name="age"> sex：<input type="text" name="sex"> BillId:<input type="text" name="bill.billId"> BillName:<input type="text" name="bill.billName"> <input type="submit" value="提交"> </form>

@RequestMapping("/action4")     //List集合类型     //不能直接在action的参数中指定List<T>类型，必须定义一个类型包装List集合     //Map与List的实现方式基本一样     //集合类型基本都一样，set也差不多，问题是如果为了获得一个集合需要刻意去包装会很麻烦     //可以通过@RequestParam结合@RequestBody等注解完成     public String action4(Model model,ParamList paramList){         model.addAttribute("message",paramList);         return "request";     }

public class ParamList {     private List<User> userList; 。。省略 }

${paramList.userList[0]}

@RequestMapping("/action5")     //基本数据类型绑定与注解属性     //@RequestParam共有3个注解属性     //required属性表示是否为必须传参，默认值为true     //defaultValue用于设置参数的默认值，如果不指定值则使用默认值，只能是String类型的     //value用于指定传入参数的名称     public String action5(Model model,@RequestParam(required=false,defaultValue="250",value="userId") Integer id){          model.addAttribute("message", id);          return "request";     }

@RequestMapping("/action6")     //List与数组绑定基本数据类型     //表单同样可行，但是@RequestParam("name")是必须的，name为页面中的表单的name,如果和参数同名则可以省去     public String action6(Model model,@RequestParam("phone")List <String> strings){         model.addAttribute("message",strings.get(0) + "," + strings.get(1) + "," + strings.get(2));         return "request";     }

<form action="/SpringMvc0911/request/action6" method="post">       phone:<input type="text" name="phone"/>       phone:<input type="text" name="phone"/>       phone:<input type="text" name="phone"/>       <button type="submit" value="提交">提交</button>   </form>

ResponseController：返回视图和String的几种方式

/**  * 定义控制器  */ @Controller @RequestMapping("/response") public class ResponseController {     @RequestMapping("/action1")     //方法返回值为String:String作为视图名称     //默认如果action返回String，此时的String为视图名称     //会去视图解析器的设定的目录下查找，查找的规则是：URL= prefix前缀+视图名称 +suffix后缀组成     public String action1(Model model) {         User user = new User();         user.setName("zhangsan");         model.addAttribute("message",user);         return "request";     }

@RequestMapping("/action2")     //String作为内容输出     @ResponseBody     //如果方法声明了注解@ResponseBody ，将内容或对象作为 HTTP 响应正文返回     //并调用适合HttpMessageConverter的Adapter转换对象，写入输出流     //些时的String不再是路径而是内容     public String action2(Model model){         model.addAttribute("message", "aaaaaaa");         return "aaaaaaa";     }

@RequestMapping("/action3")     //返回值为void,存在如下两种情况：     //1.方法名默认作为视图名:     //  当方法没有返回值时，方法中并未指定视图的名称，则默认视图的名称为方法名     //  URL= prefix前缀+控制器路径+方法名称 +suffix后缀组成(/WEB-INF/jsp/response/action3.jsp)     public void action3(Model model){         User user = new User();         user.setName("zhangsan");         model.addAttribute("message",user);     }

@RequestMapping("/action4")     //返回值为void,存在如下两种情况：     //2.直接响应输出结果     //  当方法的返回值为void，但输出流中存在输出内容时，则不会去查找视图，而是将输入流中的内容直接响应到客户端     //  响应的内容类型是纯文本     public void action4(HttpServletResponse response) throws IOException {         String s ="直接响应输出结果";         response.setContentType("text/html;charset=utf-8");         //response.setContentType(“text/html; charset=utf-8”); html         //response.setContentType(“text/plain; charset=utf-8”); 文本        // response.setContentType(“text/javascript; charset=utf-8”); json数据        // response.setContentType(“application/xml; charset=utf-8”); xml数据         response.getWriter().write(s);     }

@RequestMapping("/action5")     //返回值为ModelAndView     //可以同时指定须返回的模型与视图对象或名称     //ModelAndView有个多构造方法重载，单独设置属性也很方便     public ModelAndView action5(){         //1.只指定视图         return new ModelAndView("responseMapping");         //2.分别指定视图与模型 //        Map<String, Object> model=new HashMap<String,Object>(); //        model.put("message", "ModelAndView action5"); //        return new ModelAndView("responseMapping",model);         //3同时指定视图与模型 //        return new ModelAndView("responseMapping","message","action5 ModelAndView ");         //4分开指定视图与模型 //        ModelAndView modelAndView=new ModelAndView(); //        //指定视图名称 //        modelAndView.setViewName("responseMapping"); //        //添加模型中的对象 //        modelAndView.addObject("message", "<h2>Hello ModelAndView</h2>"); //        return modelAndView;}

@RequestMapping("/action6")     //返回值为Map     //当返回结果为Map时，相当于只是返回了Model，并未指定具体的视图     //返回视图的办法与void是一样的，即URL= prefix前缀+控制器路径+方法名称 +suffix后缀组成(/WEB-INF/jsp/response/action6.jsp)     public Map<String,Object> action6(){         Map<String, Object> model=new HashMap<String,Object>();         model.put("message", "Hello Map");         model.put("other", "more item");         return model;     }

@RequestMapping(value = "/action7")     //返回值为任意类型     //1.返回值为基本数据类型     //  当返回结果直接为int,double,boolean等基本数据类型时,会出现Unknown return value type异常     @ResponseBody     // 如果确实需要直接将基本数据类型返回，则可以使用注解@ReponseBody     public int action7(){         return 325;     }     //返回值为任意类型     //2.当返回值为自定义类型     //TODO 返回值为任意类型-2.返回值为自定义类型     //TODO 返回值为Model类型、view等 }

在项目中用到JSON类型的，修改编码格式     @RequestMapping(value="getproviderlist",produces="application/json;charset=utf-8")//     @ResponseBody     public String getProviderlist(HttpServletRequest request, HttpServletResponse response)             throws ServletException, IOException {                 System.out.println("getproviderlist ========================= ");                 List<Provider> providerList = new ArrayList<Provider>();         ProviderService providerService = new ProviderServiceImpl();         providerList = providerService.getProviderList("","");         return JSONArray.toJSONString(providerList);

异常处理

局部异常

在Service中抛异常 在controller中捕捉异常

public List<User> getUserList(String queryUserName,int queryUserRole,int currentPageNo, int pageSize) {         // TODO Auto-generated method stub         //Connection connection = null;         List<User> userList = null;         System.out.println("queryUserName ---- > " + queryUserName);         System.out.println("queryUserRole ---- > " + queryUserRole);         System.out.println("currentPageNo ---- > " + currentPageNo);         System.out.println("pageSize ---- > " + pageSize);         throw new RuntimeException("异常了"); }

@ExceptionHandler(value={RuntimeException.class})     public String handlerException(RuntimeException e,HttpServletRequest req){         req.setAttribute("e", e.getMessage());         return "../error";     }

全局异常

在mvc配置文件中添加全局异常bean

<bean class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver">         <property name="exceptionMappings">             <props>                 <prop key="java.lang.RuntimeException">../error</prop>//总共有两个error.jsp页面                 <prop key="java.lang.SQLException">error</prop>                 <prop key="java.lang.Exception">error</prop>             </props>         </property>     </bean>

异同与优劣

1、在捕捉异常时，局部异常优先捕捉，如果局部异常没有对应的异常处理方法，则走全局异常 2、局部异常的优点：可以携带request请求，可以处理特殊的异常问题，而全局异常不能携带request请求，只能在JSP页面写共用异常处理文字 3、局部异常的缺点：需要对每个controller编写异常方法。 总结：如果对异常不需要特殊处理，则配置全局异常即可

文件上传

书上案例

总路径：localhost/uploadFile0801/Request/upload String path1=request.getContextPath();//获得工程名,/uploadFile0801 String path2=request.getServletPath();//除工程名以外路径名,/Request/upload            String path3=request.getRequestURI();//path3=path1+path2,/uploadFile0801/Request/upload String path= request.getServletContext().getRealPath("/images/"); String path4=request.getSession().getServletContext().getRealPath("/images/");//这两个路径都是下面 E:\apache-tomcat-7.0.53\webapps\uploadFile0801\images

@Controller @RequestMapping("Request") public class upload0926 {     @RequestMapping(value="/upload",method=RequestMethod.POST)     public String upload(HttpServletRequest request,             @RequestParam("description") String description,             @RequestParam("file")MultipartFile file) throws IllegalStateException, IOException{         System.out.println(description);         if(!file.isEmpty()){             //上传文件路径             String path1=request.getContextPath();             String path2=request.getServletPath();                         String path3=request.getRequestURI();             String path= request.getServletContext().getRealPath("/images/");//与path4一样             String path4=request.getSession().getServletContext().getRealPath("/images/");             System.out.println("getContextPath()"+path1);             System.out.println("getServletPath()"+path2);             System.out.println("getRequestURI()"+path3);             System.out.println("getServletContext().getRealPath()"+path);             //上传文件名             String filename=file.getOriginalFilename();             File filepath = new File(path);             if(!filepath.exists()){                 filepath.mkdirs();             }             //File filepath=new File(path,filename);             //判断路径是否存在，如果不存在就创建一个             /*if(!filepath.getParentFile().exists()){                 filepath.getParentFile().mkdirs();             }*/             //将上传文件保存到一个目标文件当中             file.transferTo(new File(path+File.separator+filename));             return "success";         }else{             return "error";         }     }

<h2>文件上传</h2> <form action="${pageContext.request.contextPath}/Request/upload" enctype="multipart/form-data" method="post">     <table>         <tr>             <td>文件描述：<td>             <td><input type="text" name="description"/><td>         </tr>     </table>     <div>         <label for="uploadfile">请选择文件：</label>         <input type="file" name="file" id= "uploadfile"/>                       </div>     <div><input type = "submit" value="上传"/></div> </form>

项目案例

public String add(HttpServletRequest request,@RequestParam(value="a_idPicPath",required=false) MultipartFile attach)             throws ServletException, IOException {        //判断文件是否为空         if(!attach.isEmpty()){             String path = request.getContextPath()+File.separator+"statics"+File.separator+"uploadfiles";//这个路径不要了             String realPath= request.getSession().getServletContext().getRealPath("statics"+File.separator+"uploadfiles");                     String oldFileName = attach.getOriginalFilename();//原文件名             String suffix = FilenameUtils.getExtension(oldFileName);//原文件后缀             int filesize=500000;             if(attach.getSize()>filesize){                 request.setAttribute("uploadFileError", "上传大小不得超过500k");                 return "useradd";             }else if(suffix.equalsIgnoreCase("jpg")||suffix.equalsIgnoreCase("png")                     ||suffix.equalsIgnoreCase("jpeg")||suffix.equalsIgnoreCase("pneg")){//上传图片格式不正确                 String fileName = System.currentTimeMillis()+RandomUtils.nextInt(1000000)+"_Personal.jpg";                 File targetFile = new File(realPath,fileName);                 // 判断路径是否存在，不存在就新建这个路径                 if(!targetFile.exists()){                     //targetFile.getParentFile();                     targetFile.mkdirs();                 }                 //保存                 try {                     attach.transferTo(targetFile);                 } catch (IllegalStateException e) {                     e.printStackTrace();                     request.setAttribute("uploadFileError", "上传失败！");                     return "useradd";                 }                 //文件相对路径                 idPicPath = path+File.separator+fileName;                 //文件绝对路径                 idPicRealPath = realPath+File.separator+fileName;             }else{                 request.setAttribute("uploadFileError", "上传图片格式不正确");                 return "useradd";             }

<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">         <property name="maxUploadSize" value="5000000"/>         <property name="defaultEncoding" value="UTF-8"/>     </bean>

项目细节

<fmt:formatDate value="${user.birthday}" pattern="yyyy-MM-dd HH:mm:ss"/>

JPA

主要作用

其一，简化现有Java EE和Java SE应用开发工作

其二，Sun希望整合ORM技术，实现天下归一。

复杂sql的写法

Mybatis

初学配置

mybatis工程配置:     1、全局配置文件   XML     2、映射文件   XML     3、创建工厂   SqlSessionFactory    会话工厂     4、通过SqlSession会话进行增删改查 步骤：     1、导jar包     2、在Java Resource下建一个文件夹(config),在里面建一个全局配置文件XML(SqlMapConfig)     1)把文件头复制过来     <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">     2）把参数复制过来     <configuration>          <environments default="development">                <environment id="development">                        <transactionManager type="JDBC" />                        <dataSource type="POOLED">               <property name="driver" value="com.mysql.jdbc.Driver" />               <property name="url" value="jdbc:mysql://localhost:3306/数据库连接的名字" />               <property name="username" value="root" />               <property name="password" value="数据库密码" />            </dataSource>        </environment>     </environments>          <mappers>     <mapper resource="sqlmap/User.xml"/>     </mappers> </configuration>     3、在Java Resources的src下建实体(User)       4、配置映射文件，(config)下建XML(User)     1)把头文件粘上     <!DOCTYPE mapper    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">     2)把参数复制过来     <mapper namespace="命名空间">//不同一实体的命名空间不同     <select id="命名空间唯一标识(一条语句一个标识)" parameterType="java.lang.String(输入参数类型)" resultType="bgs.com.entity.User(输出参数类型)"> select * from user where id =#{id} </select> </mapper> 5、log4j.properties文件放在工程下(config文件夹中)     (测试时用DEBUG，上线后用error) 6、写测试     @Test     public void findUser() throws IOException{        //1、加载配置文件     String res = "SqlMapConfig.xml(全局配置文件)";       //2、获取xml路径     InputStream inputStream = Resources.getResourceAsStream(res);        //3、创建sqlsessionFactory     SqlSessionFactory s = new SqlSessionFactoryBuilder().build(inputStream);//SqlSessionFactory是接口；SqlSessionFactoryBuilder是实现类     SqlSession session = s.openSession();//SqlSession是接口；openSession是实现类        //4、SqlSession执行statement     User user = session.selectOne("test.findUser"(命名空间.空间标识), "2(输入参数类型)");     System.out.println(user.getName())<a name="_GoBack"></a> 多个测试时： 1、一个实体，多个查询语句： 1）在映射文件XML下添加select语句 2）在测试单元中添加测试 2、不同实体： 1）配实体 2）在全局映射文件下加上新的映射文件路径 3）在映射文件下配select语句 4）写测试 SQL语句： 1、select * from user where id = #{id} #{}：表示一个占位符 #{id}:#{}内的id表示接受输入参数的名称，该参数类型是简单类型(包括八种基本数据类型，String，Integer)，那么参数名称可以任意     2、 <select id="findListUser" parameterType="java.lang.String" resultType="bgs.com.entity.User"> select * from user where name like '%${value}%' </select> 模糊查询时，占位符${value}     //@Select("select * from easybuy_user where userName like concat ('%',#{name},'%')")     //@Select("select * from easybuy_user where userName like '%${name}%' and mobile=#{mobile}")     //public List<User> likeUser(@Param("name")String name,@Param("mobile")String mobile);     3、<select id="findListUsers" resultType="bgs.com.entity.User"> select * from user </select> 没有输入参数时，就不写输入参数类型

数据路配置文件

在SqlMapConfig.xml文件中配置数据库连接文件 <properties resource="db.properties"> <property name="db.driver"  value="123"></property>注意：优先加载行内配置文件！！！！外部如果有配置文件将覆盖行内value=“123”的值 </properties>

创建db.properties文件 db.driver = com.mysql.jdbc.Driver db.url = jdbc:mysql://localhost:3306/0518 db.username=root db.password=123

配置别名

在SqlMapConfig.xml文件中配置 <TypeAliases>  <typeAlias type = "entity.User" alias="user"></typeAlias>//很少用  <package name ="entity"></package>//包名 </TypeAliases>

另一种查询方式

<div> 1、mapper接口的类名的全限定名和mapper映射文件的namespace值一致。 2、mapper接口的方法名称要和mapper映射文件的statement的id一致。 3、mapper接口的方法参数类型要和mapper映射文件的statement的parameterType的值一致。 4、mapper接口的方法返回值类型要和mapper映射文件的statement的resultType的值一致。 </div>

在User.xml文件中可以设置UUID

Sring 类型UUID()

<insert id ="addUser" parameterType="User"> <selectKey keyProperty="id" resultType="string" order="BEFORE"> select UUID()//函数名要大写，order的值，也就是BEFORE也要大写 </selectKey> insert into users0728 (id,userName) values(#{id},#{userName}) </insert>

before在commit之前就可以得到uuid的返回值

int 类型UUID()

<insert id ="addUser" parameterType="User"> <selectKey keyProperty="id" resultType="int" order="AFTER"> select LAST_INSERT_ID()//在数据库中要点自增属性，再用此方法 </selectKey> insert into users0728 (userName) values(#{userName}) </insert>

after在commit之后才可以得到uuid的返回值

在代码中使用UUID.Random()

在全局配置文件中批量加载配置文件

<mappers> <mapper resource="sqlmap/User.xml"/>这是加载xml文件,与不在一个包下，注意这是斜杠//// 加载单个 <mapper class="bgs.com.mapper.UserMapper（接口与映射文件放在同一个包下，并且同名才行）"> 加载多个 <package name="bgs.com.mapper"> </mappers>

在映射文件中 resultType 与resultMap的区别

<mapper namespace="Dao.UserMapper"> <resultMap type="user" id="resultId">   //resultType被移动到这里 <result column="_userName" property="userName" /> <result column="_sex" property="gender" /> </resultMap> <select id="findUser" parameterType="string" resultMap="resultId">//resultMap的值与上面的ID一致 select  _userName,_sex from users0807 where id = #{id} </select> </mapper>

动态sql

<sql id="includeId"> <if test="gender!=null and userCode!=''"> and _sex=#{gender} </if> <if test="userName!=null and userName!=''"> and _userName=#{userName} </if> </sql> <select id="UserList" parameterType="user" resultMap="resultId"> select  * from users0807 <where> <include refid="includeId"></include> </where> </select>

在查询有in的语句里使用foreach循环

list基本类型

<select id="lookUse1" parameterType="list" resultMap="resultId"> select * from users0807 <where> id in <if test="list!=null and list!=''">     <foreach collection="list" item="id" open="(" close=")" separator=",">     #{id}     </foreach> </if> </where> </select>

封装类，把集合封装到对象中

<select id="lookUse" parameterType="user" resultMap="resultId"> select * from users0807 <where> id in <if test="listId!=null and listId!=''">     <foreach collection="listId" item="id" open="(" close=")" separator=",">     #{id}     </foreach> </if> </where> </select>

关系映射

一对一的关系映射

平铺类型

public class billUser extends sBill{     private String userName;     private String userCode; }

<resultMap type="billUser" id="resultMaps"> <result column="user_Name" property="userName"/> <result column="user_Code" property="userCode"/> </resultMap> 一对一简单的平铺关系 <select id="findUser" resultMap="resultMaps"> select s_bill.id, s_bill.productName, s_user.user_Name, s_user.user_Code FROM s_bill,s_user WHERE s_bill.userId=s_user.id; </select>

嵌套类型

public class billUser extends sBill{     private sUser user; //get,set方法省略了 }

<resultMap type="billUser" id="resultId" autoMapping="true"> <id column="id" property="id"/>          //一个查询主表的id,后者是对象中id属性  <association property="user" javaType="suser">  //前者是属性  后者是类型 <result column="user_Name" property="userName"/> <result column="user_Code" property="userCode"/> </association> </resultMap> <select id="findUser" resultMap="resultId"> select s_bill.id, s_bill.productName, s_user.user_Name, s_user.user_Code FROM s_bill,s_user WHERE s_bill.userId=s_user.id; </select>

一对多的关系映射

一作为主表

public class BillInfo extends sBill{     private List<sInfo> listInfo;//get,set省略 }

<resultMap type="BillInfo" id="resultBill" autoMapping="true"> <id column="id" property="id"/> <collection property="listInfo" ofType="sInfo" autoMapping="true"> <result column="creat_By" property="creatBy" /> </collection> </resultMap> <select id="queryBill" resultMap="resultBill"> select a.id, a.productName, b.creat_By, b.total from s_bill as a, s_info as b where a.id=b.billid </select>

多对多的关系映射

规划一下表顺序

public class packUser extends sUser{     private List<packBill> billList; } public class packBill extends sBill{     private List<packInfo> InfoList; } public class packInfo extends sInfo{     private sProduct pro; }

<resultMap type="packUser" id="List"> <id column="id" property="id"/> <result column="user_Name" property="userName"/> <collection property="billList" ofType="packBill"  autoMapping="true">     <collection property="InfoList" ofType="packInfo" autoMapping="true">     <result column="creat_By" property="creatBy"/>         <association property="pro" javaType="sProduct" autoMapping="true">         </association>     </collection> </collection> </resultMap> <select id="UserList" resultMap="List"> select s_user.id, s_user.user_Name, s_bill.productName, s_info.creat_By, s_info.total, s_pro.proName FROM s_user, s_bill, s_info, s_pro WHERE s_user.id = s_bill.userId and s_bill.id = s_info.billid and s_info.pro_id = s_pro.id </select>

一级缓存与二级缓存

<div> 查询缓存，就是在内存建立空间用来保存上次查询结果，下次再进行同样的查询时，就不用再从数据库查找结果，大大的提高速度。 mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。 mybaits提供一级缓存，和二级缓存。 mybatis默认开启一级缓存。 </div>

一级缓存

<div> 第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。 如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。 第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。 </div>

一级缓存清空 执行insert,update,delete后执行session.commit()会清空一级缓存 执行session.clearCache();也是用来清空一级缓存

二级缓存，也称外置缓存需手动打开

<div> 二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。 </div>

开启三步骤

<div>mybaits的二级缓存是mapper范围级别，除了在核心配置文件设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存。 1.在核心配置文件中加入 <settings> <setting name="cacheEnabled" value="true"/> </settings> 2. <cache /> 3.调用pojo类实现序列化接口Serializable</div>

两种禁用二级缓存api

一种是刷新缓存，默认开启，刷新掉缓存意味着就不走缓存了

使用缓存开启false，就不走缓存了

一级缓存与二级缓存的区别

二级缓存的范围更大，多个sqlSession可以共享一个UserMapper的二级缓存区域。 UserMapper有一个二级缓存区域（按namespace分），其它mapper也有自己的二级缓存区域（按namespace分）。每一个namespace的mapper都有一个二缓存区域，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。

生命周期

一级缓存的作用域是SqlSession,生命周期和SqlSession的生命周期一样，SqlSession关闭后，一级缓存释放。 二级缓存作用域为 Mapper(Namespace)；（整个项目期间application） 一级缓存和二级缓存的使用顺序 : 二级缓存———> 一级缓存——> 数据库

延时加载

先从单表查询、需要时再从关联表去关联查询，如果不需要就不从关联表查询。这样大大提高数据库性能，因为查询单表要比关联查询多张表速度要快

<setting name="lazyLodingEnable" value="true"/>//开启懒加载，默认是false <setting name="aggressiveLazyLoding" value="false">//积极懒加载默认是true,改为false，否则不能按需加载

注解开发

在接口中开发

插入返回主键ID

<selectKey keyproperty=“pojo主键Id”resultType="主键数据类型，long（这种情况是别名,是java.lang.Long的别名），简单数据类型的别名是_long" order = "AFTER表示插入之后取主键，BEFORE表示插入之前，例如uuid先取主键在插入">select last_insert_id()    受事务控制，</selectKey>

Mybatis-Spring整合

0905 第一种：通过SqlSessionTemplate和dao层实现类的方式

配置文件      <bean id ="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>         <property name="url" value="jdbc:mysql://127.0.0.1:3306/0518"></property>         <property name="username" value="root"></property>         <property name="password" value="123"></property>     </bean>          <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">         <property name="dataSource" ref="dataSource"></property>         <property name="configLocation" value="classpath:mybatis-config.xml"></property>         <property name="mapperLocations">             <list>                 <value>classpath:bgs/Dao/**/*.xml</value>             </list>         </property>     </bean>          <bean id="sqlSessionTemplate" class="org.mybatis.spring.SqlSessionTemplate">         <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"></constructor-arg>     </bean>              <bean id="userMapper" class="bgs.Dao.UserDaoImpl">         <property name="sqlSession" ref="sqlSessionTemplate"></property>//注入的目的是调用getMapper方法，如右边所示(→)     </bean>              <bean id ="userService" class="bgs.Service.UserServiceImpl">         <property name="userMapper1" ref="userMapper"></property>     </bean>

Mybatis配置文件就剩下个别名 <?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> <typeAliases> <package name="bgs.pojo"></package> </typeAliases> </configuration>

public class UserDaoImpl implements UserDao{     private SqlSessionTemplate sqlSession;     public SqlSessionTemplate getSqlSession() {         return sqlSession;     }     public void setSqlSession(SqlSessionTemplate sqlSession) {         this.sqlSession = sqlSession;     }     @Override     public List<User> findUser() {         return sqlSession.getMapper(UserDao.class).findUser();//看过来     }      }

0906 第二种：通过MapperFactoryBean和接口的方式

<context:property-placeholder location="classpath:db.properties" system-properties-mode="FALLBACK"/>     <bean id ="dataSource" class="org.apache.commons.dbcp.BasicDataSource" >         <property name="driverClassName" value="${driver}"></property>         <property name="url" value="${url}"></property>         <property name="username" value="${username}"></property>         <property name="password" value="${password}"></property>     </bean>          <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">         <property name="dataSource" ref="dataSource"></property>         <property name="configLocation" value="classpath:mybatis-config.xml"></property>         <property name="mapperLocations">//若接口与xml在一个包下（同层），则可不设置这个属性             <list>                 <value>classpath:bgs/Dao/**/*.xml</value>             </list>         </property>     </bean>          <bean id="productDao" class="org.mybatis.spring.mapper.MapperFactoryBean">         <property name="mapperInterface" value="bgs.Dao.ProductDao"></property>//这里有一个问题，如果Dao接口比较多，那就要多写几个Bean了，所以不推荐         <property name="sqlSessionFactory" ref="sqlSessionFactory"></property>     </bean>          <bean id ="productService" class="bgs.Service.ProductServiceImpl">         <property name="ProductDao" ref="productDao"></property>     </bean>

Service实现类 public class ProductServiceImpl implements ProductService{     private ProductDao productDao;         public ProductDao getProductDao() {         return productDao;     }     public void setProductDao(ProductDao productDao) {         this.productDao = productDao;     }     @Override     public List<Product> findProduct() {         List<Product> findProduct;         try {             findProduct = productDao.findProduct();             return findProduct;         } catch (RuntimeException e) {             e.printStackTrace();             throw e;         }     } }

0906 第三种：通过MapperScannerConfigurer递归扫描的方式

<context:property-placeholder location="classpath:db.properties" system-properties-mode="FALLBACK"/>     <bean id ="dataSource" class="org.apache.commons.dbcp.BasicDataSource" >         <property name="driverClassName" value="${driver}"></property>         <property name="url" value="${url}"></property>         <property name="username" value="${username}"></property>         <property name="password" value="${password}"></property>     </bean>          <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">         <property name="dataSource" ref="dataSource"></property>         <property name="configLocation" value="classpath:mybatis-config.xml"></property>//同上          <property name="mapperLocations">             <list>                 <value>classpath:bgs/Dao/**/*.xml</value>             </list>         </property>     </bean>          <context:component-scan base-package="bgs.Service"></context:component-scan>     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">         <property name="basePackage" value="bgs.Dao"></property>//包名，自动递归扫描     </bean>     </beans>

@Service("productService")//少了setter多了注解 public class ProductServiceImpl implements ProductService{     @Autowired     private ProductDao productDao;     @Override     public List<Product> findProduct() {         List<Product> findProduct;         try {             findProduct = productDao.findProduct();             return findProduct;         } catch (RuntimeException e) {             // TODO Auto-generated catch block             e.printStackTrace();             throw e;         }     } }

事务

普通xml配置事务

xmlns:tx="http://www.springframework.org/schema/tx"    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd

<context:component-scan base-package="bgs.Service"></context:component-scan>     <context:property-placeholder location="classpath:db.properties" system-properties-mode="FALLBACK"/>     <bean id ="dataSource" class="org.apache.commons.dbcp.BasicDataSource" >         <property name="driverClassName" value="${driver}"></property>         <property name="url" value="${url}"></property>         <property name="username" value="${username}"></property>         <property name="password" value="${password}"></property>     </bean>          <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">         <property name="dataSource" ref="dataSource"></property>         <property name="configLocation" value="classpath:mybatis-config.xml"></property>     </bean>     //自动把接口注册为Bean     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">         <property name="basePackage" value="bgs.Dao"></property>     </bean>          <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">         <property name="dataSource" ref="dataSource"></property>     </bean>               <tx:advice id="txAdvice" transaction-manager="transactionManager">         <tx:attributes>             <tx:method name="find*" propagation="SUPPORTS"/>             <tx:method name="add*" propagation="REQUIRED"/>             <tx:method name="del*" propagation="REQUIRED"/>             <tx:method name="update*" propagation="REQUIRED"/>             <tx:method name="*" propagation="REQUIRED"/>         </tx:attributes>     </tx:advice>     <aop:config>         <aop:pointcut expression="execution(* bgs.Service..*.*(..))" id="serviceMethod"/>     <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>     </aop:config>

public interface ProductDao {//接口     public List<Product> findProduct();          @Insert("insert into s_pro values(#{id},#{proName})")     public int addPro(Product pro); }

@Service("productService") public class ProductServiceImpl implements ProductService{     @Autowired     private ProductDao productDao;    public int addPro(Product pro) {         pro.setId("5");         pro.setProName("事务管理");         int addPro=0;         try {             addPro = productDao.addPro(pro);         } catch (RuntimeException e) {             // TODO Auto-generated catch block             e.printStackTrace();             throw e;         }         return addPro;     }

public void addProduct() throws IOException{         ApplicationContext c = new ClassPathXmlApplicationContext("shiwu.xml");         ProductService bean = (ProductService) c.getBean("productService");         Product pro = new Product();         int addPro = bean.addPro(pro);     }

通过注解配置生命式事务

public interface UserDao {     public List<User> findUser();          @Insert("insert into users0817 values(#{id},#{userName},#{userPassword},#{gender})")     public int addUser(User user); }

@Transactional @Service("UserService") public class UserServiceImpl implements UserService{     @Autowired     private UserDao userDao;     @Override     @Transactional(propagation= Propagation.REQUIRED,noRollbackFor=RuntimeException.class)//事务传播行为类型     public int addUser(User user) {         user.setId("5");         user.setGender("男");         user.setUserName("王伏");         user.setUserPassword("12345");         int addUser = 0;         try {             addUser=userDao.addUser(user);         } catch (RuntimeException e) {             // TODO Auto-generated catch block             e.printStackTrace();             throw e;         }         return addUser;     } }

@Test     public void addUser() throws IOException{         ApplicationContext c = new ClassPathXmlApplicationContext("shiwuzhujie.xml");         UserService bean = (UserService) c.getBean("UserService");         User user = new User();         int addUser = bean.addUser(user);         System.out.println(addUser);     }

导入项目

1、先进行文件覆盖

2、把资源文件夹resources给BuildPath

选择use as Source Folder

这个文件夹就会从与WebRoot平级跑到与src平级的地方，并且文件夹样子多了个包的图样

此时，该文件夹下的配置文件会在Tomcat E:\apache-tomcat-7.0.53\webapps\SMBSM\WEB-INF\classes部署

如果在运行项目时报错

则在BaseDao文件中String configFile = "resources/database.properties"; 改为String configFile = "/database.properties";因为配置文件在Tomcat根目录下

3、右键点击项目查看properties下Resource

a、查看Text file encoding设置为UTF-8

b、Resource下Deployment Assembly右边Source

本来是/src与/WebRoot 经过第二部build path后会多出/resources

c、Resource下Java Build path

添加jar包

d、java Compiler

右边查看JDK compliance 是否与eclipse的JDK保持一致

e、Web Project Setting是否为项目名

搭建服务器

搭建DB

获取阿里云的公网IP，如右图

在用户身份验证处输入 账户：root 密码：自个想

连接阿里云数据库后，查看JDK，安装JDK

<div>一、cd /user/lib/jvm</div><div>二、ll</div><div>三、vi /etc/profile，进入后只能用↓移动，如果要复制内容，需要按住i键，出现insert后，方可粘贴，按ESC退出，输入：wq保存。 粘贴内容： #set java environment</div><div>JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk-1.8.0.144-0.b01.el7_4.x86_64 JRE_HOME=$JAVA_HOME/jre CLASS_PATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar:$JRE_HOME/lib PATH=$PATH:$JAVA_HOME/bin:$JRE_HOME/bin export JAVA_HOME JRE_HOME CLASS_PATH PATH  四、source /etc/profile（无任何反应，则继续第五步） 五、java -version 查看JDK安装版本</div>

查看本地数据库，新建连接，主机名为外网IP，因为DB与阿里云服务器不在一个地区

在项目中db.properties

<div>driver=com.mysql.jdbc.Driver</div><div>url=jdbc:mysql://rm-uf64r7h42t833q3a0o.mysql.rds.aliyuncs.com:3306/smbms?useUnicode=true&characterEncoding=utf-8</div><div>user=root</div><div>password=Ywr3573439</div>

搭建服务器

CentOS中安装Tomcat

2、将apache-tomcat-8.0.26.tar.gz文件放到/usr/local目录下，执行如下脚本：

3、启动Tomcat： # /usr/local/apache-tomcat-8.5.20/bin/startup.sh //启动tomcat

4、关闭系统防火墙：

5、在阿里云服务器上开放端口：

6、验证tomcat运行：

说明tomcat启动成功

7、部署项目

8、在地址栏输入http://yourIp:8080/项目名访问项目

查看Tomcat日志

进入到logs文件夹下 tail -f  日志名 //ctrl+C退出 tail -fn 500 日志名