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