发表于： 2018-01-13 23:54:20
1 622
完成
1.Spring+Mybatis操作数据库（参考曲师兄日报）
项目结构
User类
package com.jnshu.bean;
public class User {
private int id;
private String name;
private int age;
public User() {
}
public User( String name, int age) {
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + '}';
}
}
接口UserDao
package com.jnshu.dao;
import com.jnshu.bean.User;
import java.util.List;
public interface UserDao {
void insertUser(User user);
boolean deleteUser(int id);
boolean updateUser(User user);
String selectUserNameById(int id);
User selectUserById(int id);
List<User> selectAllUsers();
}
接口Service
package com.jnshu.service;
import com.jnshu.bean.User;
import java.util.List;
public interface Service {
void addUser(User user);
boolean removeUser(int id);
boolean modifyUser(User user);
String findUserNameById(int id);
User findUserById(int id);
List<User> findAllUsers();
}
实现类ServiceImpl
package com.jnshu.service;
import com.jnshu.bean.User;
import com.jnshu.dao.UserDao;
import java.util.List;
public class ServiceImpl implements Service {
private UserDao dao;
public ServiceImpl() {
}
public ServiceImpl(UserDao dao) {
this.dao = dao;
}
public UserDao getDao() {
return dao;
}
public void setDao(UserDao dao) {
this.dao = dao;
}
public void addUser(User user) {
dao.insertUser(user);
}
public boolean removeUser(int id) {
boolean b = dao.deleteUser(id);
return b;
}
public boolean modifyUser(User user) {
boolean b = dao.updateUser(user);
return b;
}
public String findUserNameById(int id) {
return dao.selectUserNameById(id);
}
public User findUserById(int id) {
return dao.selectUserById(id);
}
public List<User> findAllUsers() {
return dao.selectAllUsers();
}
}
mybatis.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>
<typeAliases>
<typeAlias type="com.jnshu.bean.User" alias="User"/>
</typeAliases>
<!--<mappers>-->
<!--<mapper resource="UserDao.xml"/>-->
<!--</mappers>-->
</configuration>
spring-config.xml
<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:contest="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<!--读取jdbc配置文件-->
<context:property-placeholder location="jdbc.properties"/>
<!--注册数据库，配置数据源-->
<bean id="myDataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--配置sqlsessionFactory-->
<bean id="factory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="myDataSource"/>
<property name="configLocation" value="classpath:mybatis.xml"/>
<property name="mapperLocations" value="classpath:UserDao.xml"/>
</bean>
<!--获取sqlsession，实现dao-->
<bean id="userdao" class="org.mybatis.spring.mapper.MapperFactoryBean">
<property name="sqlSessionFactory" ref="factory"/>
<property name="mapperInterface" value="com.jnshu.dao.UserDao"/>
</bean>
<!--注册service实现类-->
<bean id="service" class="com.jnshu.service.ServiceImpl">
<property name="dao" ref="userdao"/>
</bean>
</beans>UserDao.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.jnshu.dao.UserDao">
<insert id="insertUser" parameterType="User" keyProperty="id" useGeneratedKeys="true">
INSERT INTO users (name,age) VALUES (#{name},#{age})
</insert>
<delete id="deleteUser" >
DELETE FROM users WHERE id=#{id}
</delete>
<update id="updateUser" parameterType="User">
UPDATE users SET name=#{name} ,age=#{age} WHERE id=#{id}
</update>
<select id="selectUserNameById" parameterType="int" resultType="String" >
SELECT name FROM users WHERE id =#{id}
</select>
<select id="selectUserById" resultType="User">
SELECT * FROM users WHERE id=#{id}
</select>
<select id="selectAllUsers" resultType="User">
SELECT * FROM users;
</select>
</mapper>
测试类TestAll
import com.jnshu.bean.User;
import com.jnshu.service.Service;
import com.jnshu.service.ServiceImpl;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.io.Serializable;
import java.util.List;
public class TestAll {
private ServiceImpl service;
@Before
public void before(){
// 创建容器
ApplicationContext ac = new ClassPathXmlApplicationContext("spring-config.xml");
// 获取bean
service = (ServiceImpl) ac.getBean("service");//这些方法都来自applicationcontext接口
}
// 插入
@Test
public void insertUser(){
User user = new User("jiji", 90);
service.addUser(user);
System.out.println(user.getId());
}
// 删除
@Test
public void deleteUser(){
boolean b = service.removeUser(7);
System.out.println(b);
}
// 修改
@Test
public void updateUser(){
User user = new User("皮", 444444);
user.setId(33);
boolean b = service.modifyUser(user);
System.out.println(b);
}
// 通过id查询姓名
@Test
public void selectUserNameById(){
String userName = service.findUserNameById(33);
System.out.println(userName);
}
// 通过id查询user
@Test
public void selectUserById(){
User user = service.findUserById(33);
System.out.println(user);
}
// 查询所有user
@Test
public void selectAllUser(){
List<User> allUsers = service.findAllUsers();
for (User user:allUsers){
System.out.println(user);
}
}
}
操作思路：所有@Test测试开始前都要先执行@before，创建容器ApplicationContex，实例化对象ac，通过ac引用方法getbean获取bean（service依赖于userdao依赖于factory依赖于myDataSourse），传给之前建好的成员变量service（serviceimpl实现类）。
以inserUser为例，先实例化一个user对象，传给变量service引用的方法addUser，即传给（UserDao类）dao对象的insertUser方法（该方法实现类为UserDao，继承于接口service，接口service又依赖于接口UserDao），通过映射配置文件UserDao.xml执行mysql insert语句，最后通过getIdz输出users表对应的Id。
2.简单了解Spring AOP
面向切面编程：Aspect Oriented Programming
AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。
主要的功能是：日志记录，性能统计，安全控制，事务处理，异常处理等等。
主要的意图是：将日志记录，性能统计，安全控制，事务处理，异常处理等代码从业务逻辑代码中划分出来，通过对这些行为的分离，我们希望可以将它们独立的裴指导业务逻辑的方法中，进而改变这些行为的时候不影响业务逻辑的代码。
可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。
在Spring中提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
有个简单的理解，就是在别人做好的程序外面可以套一个程序，比如以前的程序员做完了一个方法A(),后来他离职或调走了，你也没有源代码，但现在业务要求在执行这个方法时要写一个日志信息，那么你就用AOP来实现，实现AOP的某些接口，当方法A被执行的时候就会触发你做的写日志的功能，类似数据库的触发器，这样做的好处时原来做的方法A()不用做任何修改，它甚至不知道有这么回事，而你的程序又可以基于它的运行结果等实现你的功能需求，达到解耦的目的。
通俗的理解，就是在你项目原有的功能基础上，通过AOP去添加新的功能，这些功能是建立在原有功能的基础上的，而且原有的功能并不知道你已经添加了新的功能。比如说，你去ATM取钱，取钱是一个功能，取完钱后向你的手机发送一条取钱信息，这就是新加的功能。
AOP就是在某一个类或方法执行前后打个标记，声明在执行到这里之前要先执行什么，执行完这里之后要接着执行什么。插入了新的执行方法。
问题
今天犯困，效率低下
收获
之前看教程代码，都是一句一句看下来，那里不会看哪里，到最后也不知所云。
现在逐渐觉得应该先理解背后的逻辑，有了整体思路，再去看细节。
计划
1.学会查看日志
2.并转成Debug模式，练习调试，学会查看单步执行时的变量值。
3.买一台服务器，部署数据库到远程DB,从本地直接连远程。
返回列表
评论