myspringc如何编程

‘壹’ spring+mybatis实现事务的配置

    1、xml文件头部需要添加spring的相关支持：

    2、配置事务管理器

    3、配置需要加入事务的方法规则，或者说是一个切面

<!-- 定义事务管理器 --> 

<bean id="transactionManager"  class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 

  <property name="dataSource" ref="dataSource" /> 

</bean> 

<!--使用注释事务 --> 

<tx:annotation-driven  transaction-manager="transactionManager" />

事物配置中有哪些属性可以配置

（1）事务的传播性：@Transactional(propagation=Propagation.REQUIRED) 

      如果有事务, 那么加入事务, 没有的话新建一个(默认情况下)

（2）事务的超时性：@Transactional(timeout=30) //默认是30秒 

      注意这里说的是事务的超时性而不是Connection的超时性，这两个是有区别的

（3）事务的隔离级别：@Transactional(isolation = Isolation.READ_UNCOMMITTED)

      读取未提交数据(会出现脏读, 不可重复读) 基本不使用

（4）回滚：

指定单一异常类：@Transactional(rollbackFor=RuntimeException.class)

指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, Exception.class})

该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。

（5）只读：@Transactional(readOnly=true)

该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。

例如：

@Transactional(propagation=Propagation.REQUIRED,rollbackFor=Exception.class,timeout=1,isolation=Isolation.DEFAULT) 

public void saveUser(Map<String, String> map) throws Exception { 

    System.out.println("方法开始"); 

    for (int i = 0; i < 500000; i++) { 

            System.out.println("*"); 

        } 

    System.out.println("进入保存"); 

    userDao.saveUser(map); 

    System.out.println("退出保存"); 

} 

解释说明

事务的传播级别定义的是事务的控制范围，主要是父子事务之间的相互影响关系；事务的隔离级别定义的是事务读写的控制范围，主要是两个事务之间的相互影响关系。

传播级别：

1）、REQUIRED

如果当前方法已经在事务中，那么就以父事务执行，不需要新建事务；如果当前方法不在事务中，那么就为当前方法新建事务。回滚情况：父子方法中任何地方出现问题，都会全部回滚。

2）、SURPPORTED

如果当前方法已经在事务中，那么就以当前事务执行；如果当前方法不再事务中，那么就以非事务方式运行。如果运行在事务中，那么只要出现异常都会回滚。

3）、NOT_SURPPORTED

如果当前方法已经在事务中，那么就挂起当前事务，以非事务方式运行，方法执行完毕后，恢复事务；如果当前方法不再事务中，那么就以非事务方式执行。

4）、MANDATORY

强制以事务方式执行，如果当前方法不在事务中，那么会抛出异常。

5）、NEVER

与MANDATORY相反，强制以非事务方式执行，如果当前方法在事务中，那么会抛出异常。

6）、REQUIRED_NEW

与REQUIRED不同的是，无论该方法当前是不是在事务中，都会为自己新建一个事务。如果当前已经在事务中，那么会挂起父事务，为自己新建一个事务。父事务不影响它子事务的提交和回滚。

7）、NESTED

嵌套事务。理解Nested的关键是savepoint。他与PROPAGATION_REQUIRES_NEW的区别是，PROPAGATION_REQUIRES_NEW另起一个事务，将会与他的父事务相互独立，而Nested的事务和他的父事务是相依的，他的提交是要等和他的父事务一块提交的。也就是说，如果父事务最后回滚，他也要回滚的。而Nested事务的好处是他有一个savepoint。

例如：

ServiceA {

/**

* 事务属性配置为 PROPAGATION_REQUIRED

*/

void methodA() {

try {

//savepoint

ServiceB.methodB(); //PROPAGATION_NESTED 级别

} catch (SomeException) {

// 执行其他业务, 如 ServiceC.methodC();

}

}

}

也就是说ServiceB.methodB失败回滚，那么ServiceA.methodA也会回滚到savepoint点上，ServiceA.methodA可以选择另外一个分支，比如ServiceC.methodC，继续执行，来尝试完成自己的事务。

原文链接：https://blog.csdn.net/wgh1015398431/java/article/details/52861048

‘贰’ myspringc 有socket功能吗

第一步：在电脑打开“91手机助手”。第二步：将手机与电脑连接。用USB线把手机连接到电脑，然后在手机里更改USB的连接方式。不同手机，更改USB的连接方式的方法不同。第三步：向手机导入通讯录。1、将手机中已有的通讯录导出（目的是了解手机通讯录的格式，以免出差错）。选点“资料管理—联系人—导出—导出到Excel”，并选好保存地点，即将你手机上的通讯录导入到一个Excel格式通讯录中.2、编辑刚才导出的通讯录。打开刚才导出的Excel通讯录，删除原有联系人信息，粘贴上要导入的联系人信息，“保存”。3、把编辑好的通讯录导入手机。点选“91手机助手”中的“资料管理—联系人—导入—从Excel导入”，把刚才编辑好的通讯录导入手机。小技巧：1、联系人后面的手机、家庭电话、工作电话、备注等内容，可以只写一部分；2、避免导入重复信息。手机中已有的联系人，Excel通讯录中就不必再有。若导入过程中碰到相同姓名，会弹出提示，可根据需要选择“新建”、“复盖”或“跳过”。3、可以先导入一小部分联系人，以作试验。等操作熟练后，再导入其他联系人。导入成功后，退出“91手机助手”，断开USB连接.

‘叁’ Spring整合Mybatis一文讲透，手把手带你实操

在介绍Spring整合Mybatis原理之前，我们得先来稍微介绍Mybatis的工作原理。

在Mybatis中，我们可以使用一个接口去定义要执行sql，简化代码如下： 定义一个接口，@Select表示要执行查询sql语句。

以下为执行sql代码：

Mybatis的目的是：使得程序员能够以调用方法的方式执行某个指定的sql，将执行sql的底层逻辑进行了封装。 这里重点思考以下mapper这个对象，当调用SqlSession的getMapper方法时，会对传入的接口生成一个 代理对象，而程序要真正用到的就是这个代理对象，在调用代理对象的方法时，Mybatis会取出该方法所对应的sql语句，然后利用JDBC去执行sql语句，最终得到结果。

UserService中的userMapper属性就会被自动注入为Mybatis中的代理对象。如果你基于一个已经完成整合的项目去调试即可发现，userMapper的类型为： org.apache.ibatis.binding.MapperProxy@41a0aa7d。证明确实是Mybatis中的代理对象。 好，那么现在我们要解决的问题的就是：如何能够把Mybatis的代理对象作为一个bean放入Spring容器中？要解决这个，我们需要对Spring的bean生成过程有一个了解。

Spring启动过程中，大致会经过如下步骤去生成bean

假设有一个A类，假设有如下代码： 一个A类

一个B类，不存在@Component注解

执行如下代码：

输出结果为：com.luban.util.A@6acdbdf5 A类对应的bean对象类型仍然为A类。但是这个结论是不确定的，我们可以利用BeanFactory后置处理器来 修改BeanDefinition，我们添加一个BeanFactory后置处理器：

这样就会导致，原本的A类对应的BeanDefiniton被修改了，被修改成了B类，那么后续正常生成的bean对 象的类型就是B类。此时，调用如下代码会报错：

但是调用如下代码不会报错，尽管B类上没有@Component注解：

并且，下面代码返回的结果是：com.luban.util.B@4b1c1ea0

之所以讲这个问题，是想说明 个问题：在Spring中，bean对象跟class没有直接关系，跟 BeanDefinition才有直接关系。 那么回到我们要解决的问题：如何能够把Mybatis的代理对象作为一个bean放入Spring容器中？ 在Spring中，如果你想生成一个bean，那么得先生成一个BeanDefinition，就像你想new一个对象实 例，得先有一个class。

继续回到我们的问题，我们现在想自己生成一个bean，那么得先生成一个BeanDefinition，只要有了 BeanDefinition，通过在BeanDefinition中设置bean对象的类型，然后把BeanDefinition添加给 Spring，Spring就会根据BeanDefinition 动帮我们 成 个类型对应的bean对象。 所以，现在我们要解决两个问题：

注意：上文中我们使用的BeanFactory后置处理器，他只能修改BeanDefinition，并不能新增一个 BeanDefinition。我们应该使用Import技术来添加一个BeanDefinition。后面再详细介绍如果使用Import 技术来添加一个BeanDefinition，可以先看一下伪代码实现思路。

假设：我们有一个UserMapper接口，他的代理对象的类型为UserMapperProxy。 那么我们的思路就是这样的，伪代码如下：

但是，这里有一个严重的问题，就是上文中的UserMapperProxy是我们假设的，他表示一个代理类的类 型，然而Mybatis中的代理对象是利用的JDK的动态代理技术实现的，也就是代理对象的代理类是动态生成的，我们根本方法确定代理对象的代理类到底是什么。 所以回到我们的问题：Mybatis的代理对象的类型是什么？ 本来可以有两个答案： 1. 代理对象对应的代理类 2. 代理对象对应的接口 那么答案1就相当于没有了，因为是代理类是动态生成的，那么我们来看答案2：代理对象对应的接口如果我们采用答案2，那么我们的思路就是：

但是，实际上给BeanDefinition对应的类型设置为一个接口是行不通的，因为Spring没有办法根据这个 BeanDefinition去new出对应类型的实例，接口是没法直接new出实例的。 那么现在问题来了，我要解决的问题：Mybatis的代理对象的类型是什么？ 两个答案都被我们否定了，所以这个问题是无解的，所以我们不能再沿着这个思路去思考了，只能回到最 开始的问题：如何能够把Mybatis的代理对象作为一个bean放入Spring容器中？

总结上文的推理：我们想通过设置BeanDefinition的class类型，然后由Spring自动的帮助我们去生成对应的bean，但是这条路是行不通的。 终极解决方案 那么我们还有没有其他办法，可以去生成bean呢？并且生成bean的逻辑不能由Spring来帮我们做了，得 由我们自己来做。 FactoryBean 有，那就是Spring中的FactoryBean。我们可以利用FactoryBean去自定义我们要生成的bean对象，比如

我们定义了一个LubanFactoryBean，它实现了FactoryBean，getObject方法就是用来自定义生成bean 对象逻辑的。 执行如下代码：

将打印： lubanFactoryBean: com.luban.util.LubanFactoryBean 1@4d41cee &lubanFactoryBean: com.luban.util.LubanFactoryBean@3712b94 lubanFactoryBean-class: class com.sun.proxy. Proxy20 从结果我们可以看到，从Spring容器中拿名字为"lubanFactoryBean"的bean对象，就是我们所自定义的 jdk动态代理所生成的代理对象。

所以，我们可以通过FactoryBean来向Spring容器中添加一个自定义的bean对象。上文中所定义的 LubanFactoryBean对应的就是UserMapper，表示我们定义了一个LubanFactoryBean，相当于把 UserMapper对应的代理对象作为一个bean放入到了容器中。 但是作为程序员，我们不可能每定义了一个Mapper，还得去定义一个LubanFactoryBean，这是很麻烦的 事情，我们改造一下LubanFactoryBean，让他变得更通用，比如：

改造LubanFactoryBean之后，LubanFactoryBean变得灵活了，可以在构造LubanFactoryBean时，通 过构造传入不同的Mapper接口。 实际上LubanFactoryBean也是一个Bean，我们也可以通过生成一个BeanDefinition来生成一个 LubanFactoryBean，并给构造方法的参数设置不同的值，比如伪代码如下：

特别说一下注意二，表示表示当前BeanDefinition在生成bean对象时，会通过调用LubanFactoryBean的 构造方法来生成，并传入UserMapper的Class对象。那么在生成LubanFactoryBean时就会生成一个 UserMapper接口对应的代理对象作为bean了。 到此为止，其实就完成了我们要解决的问题：把Mybatis中的代理对象作为一个bean放入Spring容器中。

只是我们这是用简单的JDK代理对象模拟的Mybatis中的代理对象，如果有时间，我们完全可以调 Mybatis中提供的方法区生成一个代理对象。这里就不花时间去介绍了。 Import 到这里，我们还有一个事情没有做，就是怎么真正的定义一个BeanDefinition，并把它添加到Spring中， 上文说到我们要利用Import技术，比如可以这么实现： 定义如下类：

并且在AppConfig上添加@Import注解：

这样在启动Spring时就会新增一个BeanDefinition，该BeanDefinition会生成一个LubanFactoryBean对 象，并且在生成LubanFactoryBean对象时会传入UserMapper.class对象，通过LubanFactoryBean内部 的逻辑，相当于会自动生产一个UserMapper接口的代理对象作为一个bean。

总结一下，通过我们的分析，我们要整合Spring和Mybatis，需要我们做的事情如下：

作者：程序员周瑜
链接：https://juejin.cn/post/7089023062800236552

‘肆’ spring mvc mybatis 整合 大体步骤

一、简单说明
用到的框架：spring、springmvc，mybatis
开发工具：eclipse，apache-tomcat-6.0.39
jar包管理：maven
开发过程
一、建立工程
1、引入相关jar包：
<dependencies>
<!--测试包 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>
<!-- servlet的jar包 添加<scope>provided</scope>， 因为provided表明该包只在编译和测试的时候用-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
</dependencies>
二、引入mybatis相关内容并测试
1、引入JAR包
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<maven.build.timestamp.format>yyyyMMddHHmmss</maven.build.timestamp.format>
<mybatis.version>3.3.1</mybatis.version>
</properties>
<dependencies>
<!--测试包 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.8.1</version>
<scope>test</scope>
</dependency>
<!-- servlet的jar包 添加<scope>provided</scope>，因为provided表明该包只在编译和测试的时候用-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.25</version>
</dependency>
</dependencies>
这里面在pom里面使用了<properties> 标签重点看一下，在这个环节添加了数据库连接的jar包和mybatis的jar包。这里要想可以操作数据库需要编程式的读取配置文件一般放在classpath下面。这里取名为conf.xml.这个里面主要完成2件事：
a：对数据库4个基本信息的配置, b：引入mapper.xml文件。
<?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>
<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/SSM_XML"/>
<property name="username" value="root" />
<property name="password" value="root" />
</dataSource>
</environment>
</environments>
<mappers>
<!-- 注册userMapper.xml文件，-->
<mapper resource="im/fenqi/study/user/mapper/UserMapper.xml"/>
</mappers>
</configuration>
下面对这个步骤里面的内容进行详细说明：
1、创建im.fenqi.study.user.entity.User实体对象，这里导入一个lombok插件，这个插件要安装（具体网络），可以不用显示的写set/get方法。
2、创建im/fenqi/study/user/mapper/UserMapper.xml文件，这个里面是对数据库进行操作一般和 im.fenqi.study.user.mapper.UserMapper配对使用，里面注意点。
标签mapper里面的namespace的值就是配对的JAVA类im.fenqi.study.user.mapper.UserMapper
标签resultMap：是为了解决实体类的属性名字和数据库字段名字不一致的问题。主键和其他键是有区别的。
resultMap里面定义的字段和属性在对应的表和实体必须有对应的内容否则会报错。
标签trim：可以处理user（user_id，user_name，password）等问题，里面的子标签为：
prefix：前缀覆盖并增加其内容
suffix：后缀覆盖并增加其内容
prefixOverrides：前缀判断的条件
找到最前面的和条件一样的内容然后变成prefix里面的内容
例：<trim prefix="where" prefixOverrides="AND">
</trim>
根据条件判断trim里面的字符串为"AND id=#{id} AND name like #{name}"
找到最前面的AND（prefixOverrides的内容）替换成where（prefix内容）
如果没有prefixOverrides的内容就直接加在前面。
suffixOverrides：后缀判断的条件
和prefixOverrides类似。
标签if：比较简单，<if test="判断条件"></if>
标签sql：
<sql id="Base_Column_List">
id, user_id,user_name,password
</sql>
使用场景：
select <include refid="Base_Column_List" /> from user
需要返回的字段很多的时候不用每次都写一遍
3、创建im.fenqi.study.user.mapper.UserMapper类这个和上面的文件是成对出现的，这是一个接口接口里面的方法名和UserMapper.xml里面的id要一致
4、测试类userTest
在本地测试主要使用SqlSession对象二这个对象需要使用SqlSessionFactory对象才能创建，下面先说SqlSessionFactory对象是怎么得到的
a:获取配置文件config.xml的输入流：
String resource = "/conf.xml";
//从classpath里面寻找
InputStream resourceAsStream = Object.class.getResourceAsStream(resource);
b:获取SqlSessionFactory对象
SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(resourceAsStream);
c：获取SqlSession对象：
SqlSession session = factory.openSession();
d:得到层的对象
UserMapper userMapper = session.getMapper(UserMapper.class);
d：插入数据
User user = new User();
user.setUserId(UUID.randomUUID().toString());
user.setUserName("zw1");
user.setPassword("123456");
int count = userMapper.saveUserInfo(user);
session.commit();
System.out.println("insert:"+count);
三、引入spring框架并测试
首先需要引入必要的jar包，主要是spring必要的包和spring支持mybatis，jdbc的包
<!--spring基础的包 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-expression</artifactId>
<version>${spring.version}</version>
</dependency>
<!--spring+mybatis+jdbc-->
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>1.2.1</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
这个时候conf.xml这个配置文件已经不需要了，统一在spring.xml里面进行配置
1、配置数据库连接
<?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:p="http://www.springframework.org/schema/p"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.2.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
<property name="url" value="jdbc:mysql://localhost:3306/SSM_XML"></property>
<property name="username" value="root"></property>
<property name="password" value="root"></property>
</bean>
</beans>
当然这个配置可以写在properties文件里面（用到再说）
2、spring引入以后主要目的就是利用IOC容器进行创建对象，没有加入spring之前SqlSessionFactory、SqlSession、UserMapper 对象的创建都是我们硬编码实现，spring就是为了解决这些问题，最后直接返回UserMapper 给我们使用。其他的事情都在配置里完成。这里面具体操作流程以后会详细分析
3、创建SqlSessionFactory
创建这个对象需要数据源和mapper.xml配置文件的位置
<!--创建 sqlSessionFactory，给了数据源和配置路径 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"></property>
<property name="mapperLocations" value="classpath:im/fenqi/study/*/mapper/*.xml"></property>
</bean>
4、创建UserMapper 对象（这一部分还要重点研究）
需要SqlSessionFactory对象创建SqlSession对象，然后创建UserMapper 对象，所以需要SqlSessionFactory和UserMapper 接口的位置，MapperScannerConfigurer是扫描包，不要每次都创建MapperFactoryBean
<!-- 创建Mapper层的对象 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="im.fenqi.study.*.mapper" />
<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
</bean>
5、测试获取对象
ApplicationContext context = new ("/spring.xml");
UserMapper bean = context.getBean("userMapper",UserMapper.class);
List<User> userByUser = bean.getUserByUser(null);
6、这个测试还可以使用spring自带的test类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("/spring.xml")
public class springtest {

@Autowired
private UserMapper userMapper;
@Test
public void save()
{
User user = new User("zw1", 20);
userMapper.save(user);
}
四、引入springmvc框架
首先引入springmvc的JAR包
<!--springMVC相关框架 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
这个时候需要配置web.xml，也要配置springmvc.xml
1、配置web.xml
添加加载spring.xml的监听器和spring文件路径
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" version="2.5">
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring.xml</param-value>
</context-param>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:springmvc.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
</web-app>
配置Dispatcherservlet和springmvx.xml配置文件的位置
2、配置springmvc.xml文件
springmvc.xml主要配置控制器、handlerMapper、HandlerAdapter、渲染器
<?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: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-4.0.xsd
http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
<!-- 注解扫描，以包为单位 -->
<context:component-scan base-package="im.fenqi.study"/>
<!--创建控制器 -->
<bean id="/user.do" class="im.fenqi.study.user.rest.UserController">
<property name="userService" ref="userService"></property>
</bean>
<!--创建handlermapper -->
<bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"></bean>
<!--创建handlerAdapter -->
<bean class="org.springframework.web.servlet.mvc."></bean>
<!-- 配置渲染器 -->
<bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>
3、编写控制器控制器和配置的类型要一致
public class UserController implements Controller{

private UserService userService;

public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
ModelAndView modelAndView = new ModelAndView();
List<User> userList = userService.getUserByUser(null);
modelAndView.addObject("user", userList.get(0));
modelAndView.setViewName("mypage");
return modelAndView;
}

}
五、整合过程中出现的问题
1、IOC容器。
如果我使用XML配置IOC容器，自己定义一个类这个类里面的属性想用IOC容器里面的对象初始化，必须提供set/get方法。
2、JSP不能使用el表达式，这个问题要解决
这个问题是缺少jar包的问题要想jsp使用起来不出现问题需要添加下面的包,最上面的包之前添加过了
<!-- servlet的jar包 添加<scope>provided</scope>，因为provided表明该包只在编译和测试的时候用-->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
<scope>provided</scope>
</dependency>
<!--JSP -->
<dependency>
<groupId>javax.servlet.jsp</groupId>
<artifactId>jsp-api</artifactId>
<version>2.2</version>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>jstl</artifactId>
<version>1.2</version>
</dependency>
<dependency>
<groupId>taglibs</groupId>
<artifactId>standard</artifactId>
<version>1.1.2</version>
</dependency>
3、mybatis和spring的配置过程还要具体分析
A:这个里面有很多种配置这一次就详细说明一下我们这里使用的sqlSessionFactory和 MapperScannerConfigurer
sqlSessionFactory：创建的时候需要dataSource和mapper.xml的配置文件
MapperScannerConfigurer：可以整体扫描，提供基础的包名可以使用通配符，需要sqlSessionFactoryBeanName用来创建sqlSessionFactory对象再创建SqlSession对象再通过SqlSession对象创建各个mapper对象。

‘伍’ C语言如何编写

新手用啥编译器能编写c语言
c语言可以用的编译器有很多，包括Microsoft Visual C++、My Eclipse、Turbo C和gcc编译器等。Microsoft Visual C++是微软公司的免费C语言编程软件，是用户安装时必须安装的运行时组件。

‘陆’ 谈谈spring是如何实现的

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。

在这篇由三部分组成的 Spring 系列 的第 1 部分中，我将介绍 Spring 框架。我先从框架底层模型的角度描述该框架的功能，然后将讨论两个最有趣的模块：Spring 面向方面编程（AOP）和控制反转 （IOC） 容器。接着将使用几个示例演示 IOC 容器在典型应用程序用例场景中的应用情况。这些示例还将成为本系列后面部分进行的展开式讨论的基础，在本文的后面部分，将介绍 Spring 框架通过 Spring AOP 实现 AOP 构造的方式。

请参阅 下载，下载 Spring 框架和 Apache Ant，运行本系列的示例应用程序需要它们。

Spring 框架

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如图 1 所示。

图 1. Spring 框架的 7 个模块
Spring 框架图示

组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

* 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
* Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
* Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。
* Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
* Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
* Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
* Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring 框架的功能可以用在任何 J2EE 服务器中，大多数功能也适用于不受管理的环境。Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象。毫无疑问，这样的对象可以在不同 J2EE 环境 （Web 或 EJB）、独立应用程序、测试环境之间重用。

回页首

IOC 和 AOP

控制反转模式（也称作依赖性介入）的基本概念是：不创建对象，但是描述创建它们的方式。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。容器 （在 Spring 框架中是 IOC 容器） 负责将这些联系在一起。

在典型的 IOC 场景中，容器创建了所有对象，并设置必要的属性将它们连接在一起，决定什么时间调用方法。下表列出了 IOC 的一个实现模式。
类型 1 服务需要实现专门的接口，通过接口，由对象提供这些服务，可以从对象查询依赖性（例如，需要的附加服务）
类型 2 通过 JavaBean 的属性（例如 setter 方法）分配依赖性
类型 3 依赖性以构造函数的形式提供，不以 JavaBean 属性的形式公开

Spring 框架的 IOC 容器采用类型 2 和类型3 实现。

面向方面的编程

面向方面的编程，即 AOP，是一种编程技术，它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化。AOP 的核心构造是方面，它将那些影响多个类的行为封装到可重用的模块中。

AOP 和 IOC 是补充性的技术，它们都运用模块化方式解决企业应用程序开发中的复杂问题。在典型的面向对象开发方式中，可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能。在 AOP 方式中，可以反过来将日志服务模块化，并以声明的方式将它们应用到需要日志的组件上。当然，优势就是 Java 类不需要知道日志服务的存在，也不需要考虑相关的代码。所以，用 Spring AOP 编写的应用程序代码是松散耦合的。

AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中。

回页首

IOC 容器

Spring 设计的核心是 org.springframework.beans 包，它的设计目标是与 JavaBean 组件一起使用。这个包通常不是由用户直接使用，而是由服务器将其用作其他多数功能的底层中介。下一个最高级抽象是 BeanFactory 接口，它是工厂设计模式的实现，允许通过名称创建和检索对象。BeanFactory 也可以管理对象之间的关系。

BeanFactory 支持两个对象模型。

* 单态 模型提供了具有特定名称的对象的共享实例，可以在查询时对其进行检索。Singleton 是默认的也是最常用的对象模型。对于无状态服务对象很理想。
* 原型 模型确保每次检索都会创建单独的对象。在每个用户都需要自己的对象时，原型模型最适合。

bean 工厂的概念是 Spring 作为 IOC 容器的基础。IOC 将处理事情的责任从应用程序代码转移到框架。正如我将在下一个示例中演示的那样，Spring 框架使用 JavaBean 属性和配置数据来指出必须设置的依赖关系。

BeanFactory 接口

因为 org.springframework.beans.factory.BeanFactory 是一个简单接口，所以可以针对各种底层存储方法实现。最常用的 BeanFactory 定义是 XmlBeanFactory，它根据 XML 文件中的定义装入 bean，如清单 1 所示。

清单 1. XmlBeanFactory

BeanFactory factory = new XMLBeanFactory(new FileInputSteam("mybean.xml"));

在 XML 文件中定义的 Bean 是被消极加载的，这意味在需要 bean 之前，bean 本身不会被初始化。要从 BeanFactory 检索 bean，只需调用 getBean() 方法，传入将要检索的 bean 的名称即可，如清单 2 所示。

清单 2. getBean()

MyBean mybean = (MyBean) factory.getBean("mybean");

每个 bean 的定义都可以是 POJO （用类名和 JavaBean 初始化属性定义） 或 FactoryBean。FactoryBean 接口为使用 Spring 框架构建的应用程序添加了一个间接的级别。

回页首

IOC 示例

理解控制反转最简单的方式就是看它的实际应用。在对由三部分组成的 Spring 系列 的第 1 部分进行总结时，我使用了一个示例，演示了如何通过 Spring IOC 容器注入应用程序的依赖关系（而不是将它们构建进来）。

我用开启在线信用帐户的用例作为起点。对于该实现，开启信用帐户要求用户与以下服务进行交互：

* 信用级别评定服务，查询用户的信用历史信息。
* 远程信息链接服务，插入客户信息，将客户信息与信用卡和银行信息连接起来，以进行自动借记（如果需要的话）。
* 电子邮件服务，向用户发送有关信用卡状态的电子邮件。

回页首

三个接口

对于这个示例，我假设服务已经存在，理想的情况是用松散耦合的方式把它们集成在一起。以下清单显示了三个服务的应用程序接口。

清单 3. CreditRatingInterface

public interface CreditRatingInterface {
public boolean (ICustomer iCustomer);
}

清单 3 所示的信用级别评定接口提供了信用历史信息。它需要一个包含客户信息的 Customer 对象。该接口的实现是由 CreditRating 类提供的。

清单 4. CreditLinkingInterface

public interface CreditLinkingInterface {
public String getUrl();
public void setUrl(String url);
public void linkCreditBankAccount() throws Exception ;
}

信用链接接口将信用历史信息与银行信息（如果需要的话）连接在一起，并插入用户的信用卡信息。信用链接接口是一个远程服务，它的查询是通过 getUrl() 方法进行的。URL 由 Spring 框架的 bean 配置机制设置，我稍后会讨论它。该接口的实现是由 CreditLinking 类提供的。

清单 5. EmailInterface

public interface EmailInterface {
public void sendEmail(ICustomer iCustomer);
public String getFromEmail();
public void setFromEmail(String fromEmail) ;
public String getPassword();
public void setPassword(String password) ;
public String getSmtpHost() ;
public void setSmtpHost(String smtpHost);
public String getUserId() ;
public void setUserId(String userId);
}

EmailInterface 负责向客户发送关于客户信用卡状态的电子邮件。邮件配置参数（例如 SMPT 主机、用户名、口令）由前面提到的 bean 配置机制设置。Email 类提供了该接口的实现。

回页首

Spring 使其保持松散

这些接口就位之后，接下来要考虑的就是如何用松散耦合方式将它们集成在一起。在 清单 6 中可以看到信用卡帐户用例的实现。

注意，所有的 setter 方法都是由 Spring 的配置 bean 实现的。所有的依赖关系 （也就是三个接口）都可以由 Spring 框架用这些 bean 注入。createCreditCardAccount() 方法会用服务去执行其余实现。在 清单 7 中可以看到 Spring 的配置文件。我用箭头突出了这些定义。

回页首

运行应用程序

要运行示例应用程序，首先必须 下载 Spring 框架 及其所有依赖文件。接下来，将框架释放到（比如说）磁盘 c:\，这会创建 C:\spring-framework-1.2-rc2 （适用于当前发行版本） 这样的文件夹。在继续后面的操作之前，还必须下载和释放 Apache Ant。

接下来，将源代码释放到文件夹，例如 c:\ 盘，然后创建 SpringProject。将 Spring 库（即 C:\spring-framework-1.2-rc2\dist 下的 spring.jar 和 C:\spring-framework-1.2-rc2\lib\jakarta-commons 下的 commons-logging.jar）复制到 SpringProject\lib 文件夹中。完成这些工作之后，就有了必需的构建依赖关系集。

打开命令提示符，将当前目录切换到 SpringProject，在命令提示符中输入以下命令：build。

这会构建并运行 CreateCreditAccountClient 类，类的运行将创建 Customer 类对象并填充它，还会调用 CreateCreditCardAccount 类创建并链接信用卡帐户。CreateCreditAccountClient 还会通过 装入 Spring 配置文件。装入 bean 之后，就可以通过 getBean() 方法访问它们了，如清单 8 所示。

清单 8. 装入 Spring 配置文件

appContext =
new (new String[] {
"springexample-creditaccount.xml"
});
creditCardAccount =
()
appContext.getBean("createCreditCard");

回页首

结束语

在这篇由三部分组成的 Spring 系列 的第一篇文章中，我介绍了 Spring 框架的基础。我从讨论组成 Spring 分层架构的 7 个模块开始，然后深入介绍了其中两个模块：Spring AOP 和 IOC 容器。

由于学习的最佳方法是实践，所以我用一个工作示例介绍了 IOC 模式 （像 Spring 的 IOC 容器实现的那样）如何用松散耦合的方式将分散的系统集成在一起。在这个示例中可以看到，将依赖关系或服务注入工作中的信用卡帐户应用程序，要比从头开始构建它们容易得多。

‘柒’ spring mvc中的mybatis怎么使用

spring mvc+myBatis配置详解
一、spring mvc
Spring框架（框架即：编程注解+xml配置的方式）MVC是Spring框架的一大特征，Spring框架有三大特征（IOC（依赖注入），AOP（面向切面），MVC（建模M-视图V-控制器C）。框架一般用于团队开发，使用分层的方式使每个人完成不同的模块，然后再组合在一起，使完成项目。
以下是Spring mvc具有的能加速开发的功能列表：
Spring mvc中提供了一个DispatchServlet,无需额外开发Spring mvc中使用基于xml的配置文件，可以编辑，而无需重新编译应用程序Spring mvc实例化控制器，并根据用户输入来构造Bean。
Spring mvc可以自动绑定用户输入，并正确的转换数据类型。例如，Spring mvc能自动解析字符串，并设置float或decimal类型的属性.
Spring mvc可以校验用户输入，若校验不通过，则重定向回输入表单。输入校验是可选的，支持编程方式以及声明。关于这一点，Spring mvc内置了常见的校验器Spring mvc是Spring框架的一部分，可以利用Spring提供的其他能力。
Spring mvc支持国际化和本地化。支持根据用户区域显示多国语言Spring mvc支持多种视图技术。最常见的JSP技术以及其他技术包括Velocity和FreeMarker.
配置spring mvc
1、导入Spring需要的jar 包
2、配置spring-mvc.xml
复制代码
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="springframework/schema/beans"xmlns:xsi="w3/2001/XMLSchema-instance"xmlns:context="springframework/schema/context"xmlns:jdbc="springframework/schema/jdbc"xmlns:jee="springframework/schema/jee"xmlns:tx="springframework/schema/tx"xmlns:aop="springframework/schema/aop"xmlns:mvc="springframework/schema/mvc"xmlns:util="springframework/schema/util"xmlns:jpa="springframework/schema/data/jpa"xsi:schemaLocation="springframework/schema/beans springframework/schema/beans/spring-beans-3.2.xswww.66298899.comrk/schema/context springframework/schema/context/spring-context-3.2.xswww.66298899.comrk/schema/jdbc springframework/schema/jdbc/spring-jdbc-3.2.xswww.66298899.comrk/schema/jee springframework/schema/jee/spring-jee-3.2.xswww.66298899.comrk/schema/tx springframework/schema/tx/spring-tx-3.2.xswww.66298899.comrk/schema/data/jpa springframework/schema/data/jpa/spring-jpa-1.3.xswww.66298899.comrk/schema/aop springframework/schema/aop/spring-aop-3.2.xswww.66298899.comrk/schema/mvc springframework/schema/mvc/spring-mvc-3.2.xswww.66298899.comrk/schema/util springframework/schema/util/spring-util-3.2.xsd">
<!-- HandlerMapping -->
<mvc:annotation-driven/>
开启spring mvc注解扫描，如果不基于注解： 该类需要继承 CommandController 或者 其他很多 参见 spring帮助.我用的是基于注解的，这样比较方便<!-- 扫描Controller,Service -->
<context:component-scan
base-package="com.包名"/>
开启组件扫描，请确保所有的控制器都在基本包下，并且不要制定一个太宽泛的基本包</beans>
复制代码
补充：
第一个为开启spring mvc注解扫描，如果不基于注解： 该类需要继承 CommandController 或者 其他很多 参见 spring帮助.我用的是基于注解的，这样比较方便第二个为开启组件扫描Spring使用扫描机制来找到应用程序中所有基于注解的控制器类，为了能保证Spring你那个找到你的控制器，a.需要在Spring mvc中配置spring-contextb.在<context:component-scan base-package="com.包名"/>元素中指定控制器类的基本包基于此，在Controller中可以方便调用了，实例见最下方3.部署web.xmlDispatcherServlet作为Spring mvc框架中的一级控制器（前端控制器），是浏览器发送请求的入口该Servlet的全称是org.springframework.web.servlet.DispatcherServlet.
要使用这个Servlet，需要把他配置在部署描述符(web.xml),应用servlet和servlet-mapping元素如下：
相关解释：
1、servlet元素内的on-startup元素是可选的。if存在，表示它将在应用程序启动时就装在servlet并调用它的init方法。else，则在该servlet的第一个请求是加载。
2、Dispatcher Servlet将会使用spring mvc诸多默认组件。此外，初始化时，它会寻找一个在应用程序下的web-INF目录下 的配置文件，该配置文件的命名规则如下;servletName-servlet.xml其中servletName是在部署描述符中的Dispatcher Servlet的名字。如图所示，本例中的servlet-name为springmvc,则在初始化的时候会找到第二步配置的springmvc.xml文件.
3、当然springmvc.xml文件也可以放到应用程序目录中的任何地方，<init-param></init-param>元素就是为了实现这个功能的。
其中的<param-name>不用改，而<param-value>则包含配置文件的路劲。
补充一下：（1）Spring可以通过指定classpath*:与classpath:前缀加路径的方式从classpath加载文件,如bean的定义文件.
classpath*:的出现是为了从多个jar文件中加载相同的文件.
classpath:只能加载找到的第一个文件
（2）url-pattern的写法
1 三种写法
①完全匹配
<url-pattern>/test/list.do</url-pattern>
② 目录匹配
<url-pattern>/test/*</url-pattern>
③ 扩展名匹配
<url-pattern>*.do</url-pattern>
2 注意事项
容器会首先查找完全匹配，如果找不到，再查找目录匹配，如果也找不到，就查找扩展名匹配。
如果一个请求匹配多个“目录匹配”，容器会选择最长的匹配。
定义”/*.action”这样一个看起来很正常的匹配会报错？因为这个匹配即属于路径映射，也属于扩展映射，导致容器无法判断。
“/” 是用来定义default servlet映射的。
*.do它不是一个文件,并没有一个真正的.do文件存在，只是一个servlet映射.意思是URL里一切以.do结尾的URL都驱动servlet里设置的那个类;而*则是所有请求都交由servlet里设置的那个类处理！
二、MyBatis的配置和使用
Spring与MyBatis结合，主要是由Spring管理数据库访问组件Dao，数据库访问组件主要是基于MyBatis实现，在Spring环境中使用MyBatis实现数据库访问组件过程是：首先需要引入一个Spring和MyBatis整合的开发包 mybatis-spring-1.2.2.jar。在Spring配置中定义SqlSessionFactoryBean，等价于SqlSessionFactory放入Spring容器管理。（不需要开发者利用手工创建SqlSessionFactory对象，需要开发者定义式注入连接信息和SQL定义的XML信息）在Spring配置中定义MapperFactoryBean，可以根据指定的Mapper接口生成一个Mapper实现类接口。需引入引入开发包：spring ioc,spring aop，dbcp,mybatis,驱动,mybatis-spring.jar。添加Spring框架的配置文件主要有applicationContext.xml，根据user表编写实体类User，编写UserMapper.xml（定义SQL语句），并且编写UserMapper接口（与UserMapper.xml映射），在applicationContext.xml中配置组件SqlSessionFactoryBean,Mapper FactoryBean。最后测试MapperFactoryBean生成的UserMapperDao实例。
MyBatis的两个特点：
1.MyBatis采用SQL与Entity映射，对JDBC封装程度较轻2.MyBatis自己写SQL，更具有灵活性配置MyBatis
（1）导入jar包
（2）创建数据库
（3）添加MyBatis.xml配置文件
复制代码
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="springframework/schema/beans"xmlns:xsi="w3/2001/XMLSchema-instance"xmlns:context="springframework/schema/context"xmlns:jdbc="springframework/schema/jdbc"xmlns:jee="springframework/schema/jee"xmlns:tx="springframework/schema/tx"xmlns:aop="springframework/schema/aop"xmlns:mvc="springframework/schema/mvc"xmlns:util="springframework/schema/util"xmlns:jpa="springframework/schema/data/jpa"xsi:schemaLocation="springframework/schema/beans springframework/schema/beans/spring-beans-3.2.xswww.66298899.comrk/schema/context springframework/schema/context/spring-context-3.2.xswww.66298899.comrk/schema/jdbc springframework/schema/jdbc/spring-jdbc-3.2.xswww.66298899.comrk/schema/jee springframework/schema/jee/spring-jee-3.2.xswww.66298899.comrk/schema/tx springframework/schema/tx/spring-tx-3.2.xswww.66298899.comrk/schema/data/jpa springframework/schema/data/jpa/spring-jpa-1.3.xswww.66298899.comrk/schema/aop springframework/schema/aop/spring-aop-3.2.xswww.66298899.comrk/schema/mvc springframework/schema/mvc/spring-mvc-3.2.xswww.66298899.comrk/schema/util springframework/schema/util/spring-util-3.2.xsd">
<bean id="dbcp"
class="org.apachemons.dbcp.BasicDataSource">
<property name="username" value="****">
</property>
<property name="password" value="***">
</property>
<property name="driverClassName"
value="com.mysql.jdbc.Driver">
</property>
<property name="url"
value="jdbc:mysql:///cloud_note">
</property>
<!-- <property name="url" value="jdbc:mysql://localhost:3306/cloud_note?useUnicode=true&characterEncoding=utf-8"></property> -->
</bean>
<bean id="ssf"
class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dbcp">
</property>
<property name="mapperLocations"
value="classpath:com/niuniu/sql/*.xml">
</property>
</bean>
<bean id="mapperscanner"
class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="sqlSessionFactory" ref="ssf">
</property>
<property name="basePackage"
value="com.niuniu.">
</property>
</bean>
</beans>
复制代码
（4）定义表所对应的实体类，如下图所示
代码如下：
复制代码
package com.niuniu.entity;
import java.io.Serializable;
public class User implements Serializable {private String cn_user_id;private String cn_user_name;
private String cn_user_password;
private String cn_user_token;
private String cn_user_nick;
public String getCn_user_id() {
return cn_user_id;
}
public void setCn_user_id(String cnUserId) {cn_user_id = cnUserId;}
public String getCn_user_name() {
return cn_user_name;
}
public void setCn_user_name(String cnUserName) {cn_user_name = cnUserName;}
public String getCn_user_password() {
return cn_user_password;
}
public void setCn_user_password(String cnUserPassword) {cn_user_password = cnUserPassword;}
public String getCn_user_token() {
return cn_user_token;
}
public void setCn_user_token(String cnUserToken) {cn_user_token = cnUserToken;}
public String getCn_user_nick() {
return cn_user_nick;
}
public void setCn_user_nick(String cnUserNick) {cn_user_nick = cnUserNick;}
}
复制代码
（5）定义操作users表的sql映射文件UserMapping.xml复制代码<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//ibatis.apache//DTD Mapper 3.0//EN""http://ibatis.apache/dtd/ibatis-3-mapper.dtd">
<mapper namespace="com.niuniu..UserDao">
<insert id="save" parameterType="com.niuniu.entity.User">
insert into cn_user(
cn_user_id,cn_user_name,
cn_user_password,cn_user_token,
cn_user_nick)
values(#{cn_user_id},#{cn_user_name},#{cn_user_password},#{cn_user_token},#{cn_user_nick})</insert>
<select id="findByName" parameterType="string"resultType="com.niuniu.entity.User">
select * from cn_user
where cn_user_name=#{name}
</select>
</mapper>
复制代码
(6)写Controller,进行测试。
复制代码
@Controller//将类名前加上该注解，当spring启动或者web服务启动 spring会自动扫描所有包（当然，这个可以设置,见上述Springmvc的配置）作用: 就是告诉服务器这个类是MVC中的C， 这个类可以接收用户请求、处理用户请求@RequestMapping("/note")//这个控制类里面可以有很多方法，哪个方法用来处理用户请求，就在那个方法前面 加 @RequestMapping（“/xxxxx请求路径”）public class LoadNoteDetailController {@Resource//直接使用@Resource注解一个域（field）同样是可能的。通过不暴露setter方法，代码愈发紧凑并且还提供了域不可修改的额外益处。
//正如下面将要证明的，@Resource注解甚至不需要一个显式的字符串值，在没有提供任何值的情况下，域名将被当作默认值。
//该方式被应用到setter方法的时候，默认名是从相应的属性衍生出来，换句话说，命名为'setDataSource'的方法被用来处理名为'dataSource'的属性。
private NoteService noteService;
@RequestMapping("/loaddetail.do")//映射到JSP的前台页面中ajax发布的请求，打开相应的页面↑@ResponseBody ↑public NoteResult execute(String noteId){ ↑NoteResult result=noteService.loadDetail(noteId); ↑return result;//当请求处理完毕后,返回值决定了该处理完毕后,用户将跳转到那个页面.这个很重要。service调util}
}
复制代码
知识补充：
@Resource
@Resource默认按照ByName自动注入,有两个重要的属性：name和type，而Spring将@Resource注解的name属性解析为bean的名字，而type属性 则解析为bean的类型。所以，如果使用name属性，则使用byName的自动注入策略，而使用type属性时则使用byType自动注入策略。如果既 不制定name也不制定type属性，这时将通过反射机制使用byName自动注入策略。
@ResponseBody
作用：
该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。
使用时机：
返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

‘捌’ 如何用手机进行编程

这里介绍3种可以在手机上编程的app，分别是c语言编译器（c语言）、AIDE集成开发环境（java）、Qpython3(python），都不需要root，可以直接编写程序并运行，下面我简单介绍一下这3个app的安装和简单使用，主要内容如下：

1.下载安装，这里以我的vivo手机为例，直接打开“应用商店”，搜索“C语言编译器”，如下，直接点击下载安装：

测试代码如下，这里编写了2个函数，分别是2数之和和2数只差，很简单：

程序运行截图如下，需要先输入2个数，才能正常运行：

1.下载安装，这直接在应用商店里搜素“AIDE”就行，直接下载安装，如下：

这里测试一下，主要代码如下，官方自带的例子：

程序运行截图如下：

1.下载安装，这里直接在应用商店里搜索“QPython3”就行，直接下载安装，如下：

主界面如下，主要分为“终端”、“编辑器”、“程序”、“QPYPI”、“课程”、“社区”这6个模块，终端类似IDLE，编辑器类似记事本，QPYPI是第三方包和工具，程序存储官方自带的示例，课程是一些教学案例：

这里测试一下官方自带的例子—speaky.py，在“程序”这个模块下，代码如下：

点击运行按钮，程序运行截图如下：

至此，这3个app都介绍完毕。总的来说，使用起来都不错，各有各的功能，当然，还有许多其他的app也可以在手机上进行编程，像c4droid（c/c++），termux（高级终端，类似linux）等，这里我就不详细介绍了，感兴趣的可以在网上搜索一下，有相关教程和示例可供参考，希望以上分享的内容能对你有所帮助吧。

很高兴能回答你的问题

我就自己使用过的一些手机编程软件来进行说明。之前学习网页开发，为了让自己随时随地使用编程，携带方便。
第一种 html-css-js
这款软件，看着名字就知道是和html相关的网页开发，它是由踏宇 科技 开发的一款手机开发网页的APP。不仅有编程、编译功能，还可以进行网页开发学习，内附很多关于网页设计（css,js）。真正做到编写，学习两不误。

这是代码编写界面：

这是学习界面：

但哎，我现在基本不使用它来编程了，当你使用到手机键盘里的，你就知道为啥了。
第二种，C++pro
这一款手持编程APP软件，是我比较喜欢的一款，功能很强大，不仅可以编写C语言、C++、C#而且还可以编写PHP、Nodejs、go等。可以说，你拥有了这一款APP，就相当于同时拥有了多个编程APP软件啦。

这是打开后的主界面。不难发现有很多种语言的编写模块。更加强大的是，它还可以在编写代码后做一个选择，选择要运行的语言工具。

当然如果大量代码运行的话，可能会比较迟缓。

两款手机编程APP分享给大家！

这里介绍3种可以在手机上编程的app，分别是c语言编译器（c语言）、AIDE集成开发环境（java）、QPython3(python），都不需要root，可以直接编写程序并运行，下面我简单介绍一下这3个app的安装和简单使用，主要内容如下：

1.下载安装，这里以我的vivo手机为例，直接打开“应用商店”，搜索“C语言编译器”，如下，直接点击下载安装：

测试代码如下，这里编写了2个函数，分别是2数之和和2数只差，很简单：

程序运行截图如下，需要先输入2个数，才能正常运行：

1.下载安装，这直接在应用商店里搜素“AIDE”就行，直接下载安装，如下：

这里测试一下，主要代码如下，官方自带的例子：

程序运行截图如下：

1.下载安装，这里直接在应用商店里搜索“QPython3”就行，直接下载安装，如下：

主界面如下，主要分为“终端”、“编辑器”、“程序”、“QPYPI”、“课程”、“社区”这6个模块，终端类似IDLE，编辑器类似记事本，QPYPI是第三方包和工具，程序存储官方自带的示例，课程是一些教学案例：

这里测试一下官方自带的例子—speaky.py，在“程序”这个模块下，代码如下：

点击运行按钮，程序运行截图如下：

至此，这3个app都介绍完毕。总的来说，使用起来都不错，各有各的功能，当然，还有许多其他的app也可以在手机上进行编程，像c4droid（c/c++），termux（高级终端，类似linux）等，这里我就不详细介绍了，感兴趣的可以在网上搜索一下，有相关教程和示例可供参考，希望以上分享的内容能对你有所帮助吧。

用手机进行编程，也是脑洞大开了啊，不过话说回来，手机上到底能不能进行编程呢？当然是可以的，现在手机的性能可以说不亚于电脑的，那么我下面给大家分享几个用手机编程的办法。
1.c语言编译器
这个软件可以说是学习c语言的实用工具了，给大家介绍一下它的特点，就是小，没错内存只有10M左右，而且软件干净啊，使用起来没有什么广告，用起来效率也是非常高的。

2.JAVA编辑器
如果你喜欢使用JAVA这个语言的话，这款软件留非常的适合你，专门做JAVA代码开发，你可以用它做一些小 游戏 ，功能非常的强大，而且使用的功能又很简单。

可以在线编辑demo 跑基本环境 但是涉及到功能模块开发 还是需要电脑的，

手机只能简单编辑脚本 以及 代码的部分存储

坐公交坐地铁或排队等待的时候闲着没事可以在手机上编程学习，但是总得来说手机上编程不怎么舒适。

第一款： pythonista3 phython编程app，特点：编写方便，交互感强，API强大

a.编辑器包含： 1. 语法高亮 2.自动补全符号 3.个性化python键盘 等功能

b.清晰的标签，让你在各个文件间轻松切换！

c.完美的提示窗口，手机上编写命令行也能从容自如

d.方便的2d引擎库，快速写出一个小 游戏 吧

第二款： mimo 学习编程app，特点：适合学习，操作简单，界面萌化

a.趣闻教学： 可以选择一门语言进行学习，内容非常易懂，操作也简单，mimo支持23种编程语言的教程，值得玩一玩。

b.编辑也很方便

第三款：my phython quiz 帮你复习python的app。 特点：碎片化学习

没事在路上多刷刷题吧，有助于增强熟练度。

第四款： Udacity 目前最全，最优质的编程课程app。 特点：老师优质，硅谷资源，最新 科技

屏幕太小了，小心点眼睛。

网络搜索以下软件，或者编程器

NO.1 c4droid

一款手机上的c语言编译器。

个人认为手机上最好用的，没有之一！c4droid是款Android设备上的C/C++程序编译器。

NO.2 AIDE

功能强大，内置学习教程。

AIDE是一个Android Java集成开发环境，可以让你在Android系统内进行Android软件和 游戏 的开发。

NO.3 我的应用iapp

专为手机研发，代码编写简单，学习容易。

iapp还很年轻，特别需要大家的支持！

NO.4 cppdroid

和c4droid一样，是一款手机上的c语言编译器。

安卓上的C/C++编译环境,可以帮助你在手机上编写c/c++程序 ，和c4droid各有优点，cppdroid最大的优点就是可以即时报错，写一个字符就检查一遍，保证程序的正确性，而且编译速度快，虽然还有部分地方赶不上c4droid，但是和c4droid搭配还是不错的。

网络可以查查

‘玖’ c语言编程

这道题考的应该不是数组和位操作，应该是结构体的位域和联合，上面的仁兄写的结果虽然对，但是显然不符合提示中的内容。

#include<stdio.h>

structphone_switchers{
intpower:1;
intwifi:1;
intscreen:1;
intsensor:1;
intgprs:1;
intphone:1;
intunused:2;
};

unionstate{
intvalue;
structphone_switchersswitchers;
};

intmain(){
unionstatemystate={0};
scanf("0x%x",&mystate.value);
if(mystate.switchers.power)puts("电源开");
if(mystate.switchers.wifi)puts("WIFI开");
if(mystate.switchers.screen)puts("屏幕开");
if(mystate.switchers.sensor)puts("传感器开");
if(mystate.switchers.gprs)puts("GPRS开");
if(mystate.switchers.phone)puts("电话开");
return0;
}

而且楼上的大哥输入的时候0x3f这样的输入是接收不了的

‘拾’ spring boot在eclipse中怎么用

1.Eclipse中安装STS插件：
Help -> Eclipse Marketplace…
Search或选择“Popular”标签，选择Spring Tool Suite (STS) for Eclipse插件，安装：
2.New -> Project…

找到Spring目录，选择Spring Starter Project，Next

3、填写跟项目相关的各种信息，然后Next
4.选择需要的Dependency，然后Next：
5.Next，然后Finsh，新项目就创建好了，各个目录如下：
6.右键MySpringBootApplication中的main方法，Run As -> Spring Boot App，项目就可以启动了。
package com.example;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MySpringBootApplication {
public static void main(String[] args) {
SpringApplication.run(MySpringBootApplication.class, args);
}
}
12345678910111213

由于选择了web dependency默认启动一个Tomcat，8080端口监听
7.把application.properties改名为application.yml（个人喜欢），修改Tomcat的启动端口：
server:
port: 8081