JavaWeb (3: JDBC et MVC)

Varios databases cum JDBC coniungere, tantum opus est ut diversas sarcinas coegi database oneres, et de differentiis in linguis operandis datorum solliciti non debes.

2.Write JDBC progressio

crea database mensam


CREATE TABLE users(
    id INT PRIMARY KEY,
    `name` VARCHAR(40),
    `password` VARCHAR(40),
    email VARCHAR(60),
    birthday DATE
);
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(1,'张三','123456','[email protected]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(2,'李四','123456','[email protected]','2000-01-01');
INSERT INTO users(id,`name`,`password`,email,birthday)
VALUES(3,'王五','123456','[email protected]','2000-01-01');
SELECT * FROM users;

Import database clientelae


<!--mysql的驱动-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.31</version>
</dependency>

③ Usus JDBC:

Ⅰ. Onerare coegi database (pons inter programmata Java et datorum

Ⅱ. Vitam nexum, a nexu inter Java progressio et database

Ⅲ

Ⅵ. Claudere nexum


public class JDBCTest {
    public static void main(String[] args) throws Exception {
        //配置信息
        //要连接的数据库URL（解决中文乱码问题：useUnicode=true&characterEncoding=utf8&useSSL=true）
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        //连接的数据库时使用的用户名
        String username = "root";
        //连接的数据库时使用的密码
        String password = "123456";
        Connection conn = null;
        Statement st = null;
        ResultSet rs = null;
        
        try {
            //1.加载驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
            //2.获取与数据库的链接
            conn = DriverManager.getConnection(url, username, password);
            //3.获取用于向数据库发送sql语句的statement对象
            st = conn.createStatement();
            String sql = "select id,name,password,email,birthday from users";
            //4.向数据库发sql,并获取代表结果集的resultset对象
            //查：executeQuery    增删改：executeUpdate
            rs = st.executeQuery(sql);
            //5.取出结果集的数据
            while (rs.next()) {
                System.out.println("id=" + rs.getInt("id"));
                System.out.println("name=" + rs.getString("name"));
                System.out.println("password=" + rs.getString("password"));
                System.out.println("email=" + rs.getString("email"));
                System.out.println("birthday=" + rs.getDate("birthday"));
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //6.关闭链接，释放资源（先开后关）
                rs.close();
                st.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}

3. Detailed analysis

(1) Database url

jdbc:mysql://localhost:3306/xxx

jdbc	protocol
mysql	sub-protocol
localhost: 3306	exercitum: portum
xxx	database

Quomodo scribere consuevit database inscriptiones URL:

Oraculum scripturae: jdbc: oraculum: tenue;@localhost:1521: xxx
SqlServer写法：jdbc:microsoft:sqlserver://localhost:1433; DatabaseName=xxx
MySql scribendi methodus: jdbc:mysql://localhost:3306/xxx

(2) Connection genus

Connexio adhibetur ad nexus datorum repraesentandos, et collectio maximi momenti est in programmatibus datorum.

Omnes interactiones inter clientem et database per nexum obiectum complentur.communes rationes hujus rei;

createStatement ()	Facere id quod mittit sql ad datorum
prepareStatement (sql)	Facere PrepareSatement quod mittit precompiled sql datorum
setAutoCommit (Boolean autoCommit)	Set sive transactions statim commiserunt
committere()	Submit transaction in link
reverti ()	Reversum transactionis in hac pagina

(III) Editio classis

Obiectum enuntiationis SQL propositiones mittebat ad rationes rei publicae datorum communes.

executQuery (String sql)	Solebant mittere propositiones interrogationes ad notitias et proventus ex statuto redde
executUpdate (String sql)	Solebant mittere inserta, renovatio vel delere propositiones datorum et numerum ordinum in datorum renovatorum reddere
faciam (String sql)	Mittebat arbitraria sql dicta datorum
addBatch (String sql)	Multa sql dicta in massam
executeBatch ()	Mitte massam sql constitutionibus datorum ad supplicium

Animadverte:

Ad efficientiam operandi emendandam, exsecutio methodi plerumque directe non adhibetur.

Pro his utere: execu- tiones pro queries;

(4) ResultSet class

ResultSet repraesentare proventuum Sql declarationum exsecutionis.

Resultset Cum encapsulans effectus exsecutionis statuto, uteresimilis mensamvia。

ResultSet obiectum tenet cursorem monstrans ad mensam data ordines.Primo, cursor ante primum ordinem。

Vocans ResultSet.next () methodus cursorem punctum ad certas notitias ordine facere potest, et modum getxxx vocare ut notitia ordinis obtineat.

Get aliqua species data

getObject (int index)	Adepto objectum secundum numerum columnarum
getObject (linea columnName)	Adepto res secundum praefinitum proprium nomen

Get notitia de consimili, ut questus Missa genus

getString (int index)	A Missa secundum certum numerum columnarum
getString (String columnName)	Missa ut secundum speciem attributi nominis objectum

③ Quomodo librum eventum pone:

deinde()	movere ad proximam lineam
Previous ()	movere ad priorem aciem
absoluta (int row)	Movere certa linea
beforefirst ()	Movere frontem resultSet
afterLast ()	Movere ad finem resultSet

(5) Release resources

Postquam programmatis Jdbc cursus finitur, memento dimittere res quae a programmatis creatae sunt penitus cum database in processu currens.

Haec res plerumque ResultSet, Statement et Connection obiecta.

Praesertim obiecto Connection, rarissimum est auxilium et statim post usum dimitti debet.

Si Connexio prompte et recte claudi non potest, facile ad systema downtime ducere potest.

Ut subsidia emissio codicis detegere possit, subsidia emissio codicis etiam in novissima constitutione collocanda est.

4.SQL problema iniectio

Duae quaestiones sunt, cum enuntiatio utens ad progressionem:

Fila chordae saepe scindendae sunt, et error rate altus est


String username = "zhangsan";
String password = "123";
String sql = "select * from users where name='"+username+"' and password='"+password+"'";
ResultSet rs = st.executeQuery(sql);

Est potential periculum SQL iniectio

SQL iniectio: Iniectio illicita SQL enuntiata in usorem inita, adhibitis technicis callidis ad chordas splices efficiens SQL ambitum brevem, data datorum furandi.


public class SQLTest {
    public static void main(String[] args) throws Exception {
        // 正常登陆sql：select * from users where name='张三' and password ='123456'
        //login("张三","123456");
        // SQL 注入：select * from users where name='' and password ='123456' or '1'='1'
        login("", "123456' or '1'='1");
    }
 
    public static void login(String username, String password) throws Exception {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String dbUsername = "root";
        String dbPassword = "123456";
 
        //1.加载驱动
        Class.forName("com.mysql.cj.jdbc.Driver");
        //2.获取与数据库的链接
        Connection conn = DriverManager.getConnection(url, dbUsername, dbPassword);
        //3.获取用于向数据库发送sql语句的statement
        Statement st = conn.createStatement();
        String sql = "select * from users where name='" + username + "' and password='" + password + "'";
        System.out.println(sql);
        //4.向数据库发sql,并获取代表结果集的rs
        ResultSet rs = st.executeQuery(sql);
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        //6.关闭链接，释放资源
        rs.close();
        st.close();
        conn.close();
    }
}

operatio effectus;

Animadverte:

Primatus et in SQL enuntiatio maior est quam vel, sic exsecutum SQL aequivalet ut eligere * ab utentibus ubi '1' = '1';

Solutio:Usus Praeparationis, genus constitutionis, quae munus SQL placeholder praebet.

Non opus est chordis splices, et notitia ab usore inita plene detegatur, quo tutius fiat.


public class PSTest {
    public static void main(String[] args) throws Exception {
        // 正常登陆sql：select * from users where name='张三' and password ='123456'
        //login("张三","123456");
        // SQL 注入：select * from users where name='' and password ='123456' or '1'='1'
        login("", "123456' or '1'='1");
    }
 
    public static void login(String username, String password) throws Exception {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String dbUsername = "root";
        String dbPassword = "123456";
 
        Class.forName("com.mysql.cj.jdbc.Driver");
 
        Connection conn = DriverManager.getConnection(url, dbUsername, dbPassword);
        //获取用于向数据库发送预编译sql语句的prepareStatement
        String sql = "select * from users where name = ? and password = ?";
        System.out.println(sql);
        PreparedStatement ps = conn.prepareStatement(sql);
        //给占位符 ? 填充数据
        ps.setString(1, username);
        ps.setString(2, password);
        ResultSet rs = ps.executeQuery();
        if (rs.next()) {
            System.out.println("登录成功");
        } else {
            System.out.println("登录失败");
        }
        rs.close();
        ps.close();
        conn.close();
    }
}

operatio effectus;

5.JDBC transactions

Transactio refertur ad rationem operationum, vel omnia prospera vel omnia adversa (principium ACID).

Cum programma Jdbc obtinet Connexionem objectum e datorum, obiecto Connection defalta sponte negotium datorum subiciet.

Si modum hunc default submissionem averte vis et plures SQLs in una re perfici permitte, sequenti JDBC transactionis constitutione uti potes.

Connection.setAutoCommit(falsus);	satus transaction
Connection.rollback();	Reversum transaction
Connection.commit();	committere transaction

crea rationem mensam


/*创建账户表*/
CREATE TABLE account(
    id INT PRIMARY KEY AUTO_INCREMENT,
    NAME VARCHAR(40),
    money DECIMAL(9,2)
);
/*插入测试数据*/
insert into account(name,money) values('A',1000);
insert into account(name,money) values('B',1000);
insert into account(name,money) values('C',1000);

Simulate negotium sem cum translatio prospere


//失败后让数据库自动回滚事务
public class Demo {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
        String username = "root";
        String password = "123456";
        Connection conn = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(url, username, password);
 
            //通知数据库开启事务，false表示开启
            conn.setAutoCommit(false);
 
            String sql1 = "update account set money=money-100 where name = 'A' ";
            conn.prepareStatement(sql1).executeUpdate();
 
            //模拟执行完SQL1之后程序出现了异常而导致后面的SQL无法正常执行，事务也无法正常提交
            int x = 1/0;
 
            String sql2 = "update account set money=money+100 where name = 'B' ";
            conn.prepareStatement(sql2)executeUpdate();
 
            //sql1 和 sql2都顺利执行，就提交事务
            conn.commit();
            System.out.println("成功！！！");
        } catch (Exception e) {
            //出现异常，通知数据库回滚事务
            conn.rollback();
            e.printStackTrace();
        } finally {
            conn.close();
        }
    }
}

6.JDBC instrumentum classis

In diversis petitionibus, necesse est ut singulis temporibus facultates emissionis datorum coniungere, et multum repetitum codicem scribetur.

Encapsulate nexum datorum praeparationem et operationes emissio in genus instrumentum et eam directe vocant cum ea utens ad vitandum codicem repetitum scribens.


public class JdbcUtil {
    private static Connection connection;
    private static String url = "jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8&useSSL=true";
    private static String username = "root";
    private static String password = "123456";
 
    //驱动（类）只需要加载一次，放静态代码块即可
    static {
        try {
            //加载数据库驱动
            Class.forName("com.mysql.cj.jdbc.Driver");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    // 获取数据库连接对象
    public static Connection getConnection() throws SQLException {
        return DriverManager.getConnection(url, username, password);
    }
 
    // 释放资源（利用多态：Statement 和 PreparedStatement 都可以传进来）
    public static void release(Connection conn, Statement st, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (st != null) {
                st.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Causam voca, ut: user addendi


 
    public void add(String name, String password) {
        Connection conn = null;
        PreparedStatement ps = null;
        try {
            conn = JdbcUtil.getConnection();
            String sql = "insert into users(name,password) values(?,?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, name);
            ps.setString(2, password);
            ps.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JdbcUtil.release(conn, ps, null);
        }
    }

7. Database nexu piscinam

(1 Overview

JDBC processum progressionis:

Ⅰ .

Ⅲ

Ⅳ. Scripto SQL dicta

Connexio database per DriverManager obtinetur. Quoties obtinetur, debes adhibere ad datorum connexionem et cognoscere nomen et tesseram usoris.

Users nexum a datorum pro unaquaque petitione obtinere necesse est, et nexum cum datorum creandis plerumque magnas facultates inter se consumit et longum tempus ad creandum sumit.

Quoties enuntiatio SQL exsecuta est, nexus disiungitur, quae vastitatem opum ac nexus datorum non bene reddi possunt.

Posito quod pagina 100,000 visitationes in die recipiat, ministrator datorum 100,000 nexus creare debet, quae ingens perditio opibus datorum datorum facile memoriam augere et dilatationem machinae causare potest.

Solutio: Database nexu piscinae

Fundamentalis idea nexus cum database piscinis:

Piscinam quiddam pro datorum constitue et certum numerum obiectorum nexuum in quiddam piscinae praemisso pone.

Cum vis nexum database obtinere, solum opus est ut obiectum e quiddam piscinae accipias.

Post usum, in piscinam quiddam reposuit ad usum proximae petitionis, consequendi reuse opum sine necessitate repetitae creationis.

Cum obiecti nexus otiosi non sint in nexu piscinae datorum, novae petitiones exspectationem intrabunt et alia fila nexum emittentem exspectabunt.

(2) Usus

Connexio datorum JDBC piscina perficitur usura interfaciei javax.sql.DataSource. DataSource est interfacies officialiter a Java.

Cum ea utendo, tincidunt non opus est ad interfaciendum se efficiendum et instrumenta tertia factionis uti possunt.

C3P0 est communis exsecutio partium tertiarum.

Vestigia usus:

importare clientelas in pom.xml


	<dependency>
	    <groupId>com.mchange</groupId>
	    <artifactId>c3p0</artifactId>
	    <version>0.9.5.2</version>
	</dependency>

Scribe code


public class DataSourceTest {
    public static void main(String[] args) {
        try {
            //创建C3P0数据库连接池
            ComboPooledDataSource dataSource=new ComboPooledDataSource();
            dataSource.setDriverClass("com.mysql.cj.jdbc.Driver");
            dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/jdbc?useUnicode=true&characterEncoding=utf8");
            dataSource.setUser("root");
            dataSource.setPassword("123456");
            //设置初始化连接个数
            dataSource.setInitialPoolSize(5);
            //设置最大连接个数（连接池中不够，可以继续申请，申请后最终的上限）
            dataSource.setMaxPoolSize(20);
            //当连接对象不够时，再次申请的连接对象个数
            dataSource.setAcquireIncrement(5);
            //设置最小连接数（当连接池中剩余2个连接对象时，就去申请 --> 提前做准备）
            dataSource.setMinPoolSize(2);
            Connection conn=dataSource.getConnection();
 
            //SQL操作...
 
            //将连接还回到数据库连接池中
            conn.close();
        } catch (PropertyVetoException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Animadverte:

Connexio per methodum tradita: com.mysql.cj.jdbc.ConnectionImpl@3c153a1

Connexio consecuta C3P0: com.mchange.v2.c3p0.impl.NewProxyConnection@6156496

sic,Etsi omnes arctam methodum vocant, exsecutionem classes diversae sunt, ratio rescribendi etiam alia est.。

Arcta methodus in C3P0 directe non destruit nexum resource, sed nexum redit ad nexum datorum piscinæ.

Superior methodus parametros occidendi ad piscinam nexum datorum directe in programmate Javae scripsit.

Hoc adoptaturhardcodevia,Omni tempore mutare configurationemOpus recompile, novum genus lima generare, efficacia nimis humilis。

In ipsa evolutione, informatio configurationis de C3P0 in tabella xml definitur, et programmatis Javae tantum opus est ut limam configurationem oneret ad perficiendam initializationem operationis nexus datorum piscinae.

Postea solum debes conformationem mutare et figuram in xml sine recompensatione mutare.

Vestigia usus:

① In directorio facultatum, novum fasciculum crea nomine c3p0-config.xml

② imple in configuratione informationem in c3p0-config.xml:


<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
    <!--配置连接池mysql-->
    <named-config name="C3P0Test">
        <!--   指定连接数据源的基本属性     -->
        <property name="driverClass">com.mysql.cj.jdbc.Driver</property>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc?useUnicode=true&amp;characterEncoding=utf8</property>
        <property name="user">root</property>
        <property name="password">123456</property>
 
        <!--   设置初始化连接个数     -->
        <property name="initialPoolSize">5</property>
        <!--   设置最大连接个数（连接池中不够，可以继续申请，申请后最终的上限）     -->
        <property name="maxPoolSize">20</property>
        <!--   当连接对象不够时，再次申请的连接对象个数     -->
        <property name="acquireIncrement">5</property>
        <!--   设置最小连接数（当连接池中剩余2个连接对象时，就去申请 -> 提前做准备） -->
        <property name="minPoolSize">2</property>
    </named-config>
</c3p0-config>

Write Java progressio


public class DataSourceTest {
    public static void main(String[] args) {
        try {
            //创建C3P0数据库连接池
            ComboPooledDataSource dataSource=new ComboPooledDataSource("C3P0Test");
            Connection conn=dataSource.getConnection();
            System.out.println(conn);
            //将连接还回到数据库连接池中
            conn.close();
        }catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

Animadverte:

① Parameter in methodo constructionis ComboPooledDataSource est nomen attributi valoris nominis config tag figuratus in c3p0-config.xml.

② Hoc tempore, instrumentum classis JDBC mutari potest sicut:


public class JdbcUtil {
    private static DataSource dataSource;
 
    static {
        dataSource = new ComboPooledDataSource("C3P0Test");
    }
 
    // 获取数据库连接对象
    public static Connection getConnection() throws SQLException {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }
 
    // 释放资源（利用多态：Statement 和 PreparedStatement 都可以传进来）
    public static void release(Connection conn, Statement st, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (st != null) {
                st.close();
            }
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

8.DBUtils


    public static Student findById(Integer idx) {
        Connection conn = null;
        PreparedStatement st = null;
        ResultSet rs = null;
        Student stu = null;
        try {
            conn = JdbcUtil.getConnection();
 
            String sql = "select * from student where id = ?";
            PreparedStatement ps = conn.prepareStatement(sql);
            //给占位符 ? 填充数据
            ps.setInt(1, idx);
            rs = ps.executeQuery();
            //取出结果集的数据
            while (rs.next()) {
                Integer id = rs.getInt(1);
                String name = rs.getString(2);
                Double score = rs.getDouble(3);
                Date birthday = rs.getDate(4);
                stu = new Student(id, name, score, birthday);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭链接，释放资源
                rs.close();
                st.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

In codice supradicto, operationes implendi locatores cum notitia et notitias e statuto extrahendi nimis gravia sunt.

Si 100 attributa sunt in Mensa Studentium, tunc 100 ordines scribendos debebimus in fascia notitias recuperandi, et etiam multos ordines ad implendum locatores habebimus.

Solutio:DBUtils tincidunt integram datam encapsulationis adiuvare possunt (mapping of result sets to Java objects).

Vestigia usus:

importare clientelas in pom.xml


<dependency>
	<groupId>commons-dbutils</groupId>
	<artifactId>commons-dbutils</artifactId>
	<version>1.6</version>
</dependency>

Scribe code


    public static Student findById(Integer idx) {
        Connection conn = null;
        Student stu = null;
        try {
            conn = JdbcUtil.getConnection();
 
            String sql = "select * from student where id = ?";
            //使用DBUtils
            QueryRunner qr = new QueryRunner();
            stu = qr.query(conn, sql, new BeanHandler<>(Student.class), idx);
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭链接，释放资源
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return stu;
    }

Hic, completis placeholders et eximendis effectibus statutis duabus lineis codicis effici potest.

singillatim:

① Quaesitio methodus transire debet in 4 parametris:

Connection object

SQL dicitur

Classis exsecutionem objecti interface ResultSetHandler (species conversio debet esse: Student.class)

Morbi ut populatio placeholders

② ResultSetHandler interfacies adhibetur ad processum proventuum causarum. Potest eventus quaesiti converti causas in Java objecta.

BeanHandler	Map exitum in Java objectum (ut objectum Student)
BeanListHandler	Proventus describendi in collectionem electronicarum constitutus (ut: List<Student > )
MapHandler	Proventus Map pone in objecto collectionis Map (ie: Map<String,Object> clavis: nomen attributum;
MapListHandler	Proventus tabula geographica pone in collectione MapList (id est: List" <Map<<String,Object> >)

③ Parameter ut implendi locumtenentis modulus variabilis est, ut quilibet numerus parametri praeteriri possit ut diversis utentium necessitatibus occurrat.

④ Objectum ordinis conversi (Discipulus class) modulatorem habere debet, secus propositum errorem nuntiabit.

rationem;Fundum iacuit hoc genus per Student.class, et deinde percogitationis mechanismInveni parametrum fabricatorem huius ordinis et suum obiectum crea.

Nomen attributi in genere prorsus idem esse debet ac nomen agri in tabula datorum.

Quia postquam res creata est, cum valores obiecti attribuentes proprietates ex statuto fundatae, inquisitio et assignatio fiunt ex nomine.

11. MVC ORDO architecturae

Quid est MVC?

Exemplar: exemplar (ministerium, dao, entis)
View: View (jsp, html, app client)
Controller: Controller (Servlet, Hander, Actio)

Post petitionem in applicatione JavaWeb intrat, Moderator petitionem accipit, processus negotium logices agit, et tandem exitum ad utentis redit (View + Model).

1. Introductio

Primis annis, cum applicationes interretiales operandi, utentes directe accesserunt ad imperium lavacrum, et iacuit moderatio recta datorum operare potuit:

servlet - CRUD (adde, delere, mutare)->database

In codice servletti: petitiones processus, responsiones, sententia salit, processus JDBC, processus negotii codicis, et processus codicis ratio.

Incommoda:Propositum est valde tumidus et ad sustentationem non conducit

solutio; Nihil est quod alterum tabulatum addens solvere non potest, si sit, alium tabulatum addat!

2. mvc tres ORDO architecturae

Model

Negotium processus: negotiatio logica (Service)
Data perseverantia iacuit: CRUD (DAO data pertinacia objecti)

view

ostentationem data
Praebere nexum petitionem Servlet incipiendi (a, forma, img...)

Controller (Servlet)

Accipere petitionem usoris: (req, petitionem parametri, notitia sessionis)
Tradere negotium accumsan ut computetur in codice correspondente
Imperium visum jump

Usorem et administratorem sume in exemplum:

Stratum moderatoris:


@WebServlet("/login")
public class LoginServlet extends HttpServlet {
 
    private LoginService loginService = new LoginServiceImpl();
 
    /* 处理登录的业务逻辑*/
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        String username = req.getParameter("username");
        String password = req.getParameter("password");
        String type = req.getParameter("type");
        Object object = loginService.login(username,password,type);
        if(object != null){
            HttpSession session = req.getSession();
            switch (type){
                case "reader":
                    Reader reader = (Reader) object;
                    session.setAttribute("reader",reader);
                    //跳转到用户的首页
                    resp.sendRedirect("/book?page=1");
                    break;
                case "admin":
                    Admin admin = (Admin) object;
                    session.setAttribute("admin",admin);
                    //跳转到管理员的首页
                    resp.sendRedirect("/admin?method=findAllBorrow&page=1");
                    break;
            }
        }else{
            resp.sendRedirect("login.jsp");
        }
    }
 
}

Service accumsan:


public interface LoginService {
    //利用多态，动态返回不同类型的对象
    public Object login(String username,String password,String type);
}


public class LoginServiceImpl implements LoginService {
 
    private ReaderRepository readerRepository = new ReaderRepositoryImpl();
    private AdminRepository adminRepository = new AdminRepositoryImpl();
 
    @Override
    public Object login(String username, String password,String type) {
        Object object = null;
        //业务逻辑处理：根据type的值，来选择调用不同的登录方法，去查找不同的表
        switch (type){
            case "reader":
                object = readerRepository.login(username,password);
                break;
            case "admin":
                object = adminRepository.login(username, password);
                break;
        }
        return object;
    }
}

Dao / repositorium iacuit:


public interface AdminRepository {
    public Admin login(String username,String password);
}


public interface ReaderRepository {
    public Reader login(String username,String password);
}


public class AdminRepositoryImpl implements AdminRepository {
    //管理员的登录方法（和数据库交互）
    @Override
    public Admin login(String username, String password) {
        Connection connection = JDBCTools.getConnection();
        String sql = "select * from bookadmin where username = ? and password = ?";
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Admin admin = null;
        try {
            statement = connection.prepareStatement(sql);
            statement.setString(1,username);
            statement.setString(2,password);
            resultSet = statement.executeQuery();
            if(resultSet.next()){
                admin = new Admin(resultSet.getInt(1),resultSet.getString(2),resultSet.getString(3));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(connection,statement,resultSet);
        }
        return admin;
    }
}


public class ReaderRepositoryImpl implements ReaderRepository {
    //用户的登录方法（和数据库交互）
    @Override
    public Reader login(String username, String password) {
        Connection connection = JDBCTools.getConnection();
        String sql = "select * from reader where username = ? and password = ?";
        PreparedStatement statement = null;
        ResultSet resultSet = null;
        Reader reader = null;
        try {
            statement = connection.prepareStatement(sql);
            statement.setString(1,username);
            statement.setString(2,password);
            resultSet = statement.executeQuery();
            if(resultSet.next()){
                reader = new Reader(resultSet.getInt(1),resultSet.getString(2),resultSet.getString(3),resultSet.getString(4),resultSet.getString(5),resultSet.getString(6),resultSet.getString(7));
            }
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            JDBCTools.release(connection,statement,resultSet);
        }
        return reader;
    }
}

Technology sharing