'분류 전체보기'에 해당되는 글 278건

  1. 2007.12.18 [JSP] HttpSessionBindingListener (펌)
  2. 2007.12.18 [JSP] JSP 캐쉬 제거
  3. 2007.12.18 [JAVA] Stand-alone Persistence in a Java SE Project
  4. 2007.12.18 DBHelper Plugin User’s Guide
  5. 2007.12.17 [JAVA] 기본!
  6. 2007.12.17 [JAVA] dbhelper
  7. 2007.12.17 [JAVA] ms-sql2005 최종본
  8. 2007.12.17 [JAVA] java msql 연동 2번째
  9. 2007.12.17 DAO (Data Access Objects) 요약
  10. 2007.12.17 고승덕 변호사의 글

[JSP] HttpSessionBindingListener (펌)

Web/JSP
2007. 12. 18. 09:48
출처 : http://blog.naver.com/korekiss/20038228350

HttpSessionBindingListener 는 웹에서 동시 사용자의 수 또는 하나의 아이디로 동시접속을 제한 할때 유용한 인터페이스 이다.  HttpSessionBindingListener 는 두개의 메소드를 지니는데 valueBound() 와 valueUnbound() 메소드 이다.
 
valueBound() 는 HttpSessionBindingListener 클래스의 인스턴스가 세션에 attribute로
등록될떄 호출된다  session.setAttribute(플래그, 값)
valueUnbound()는 session.removeAttribute(플래그); 사용시
또는 세션종료시  session.invalidate()호출된다.
 
다음은 이를 이용한 동시 사용자및 중복 로그인 방지 프로그램이다.
 
 
LoginManager.java
 
package cookie;
 
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionBindingListener;
import javax.servlet.http.HttpSessionBindingEvent;
import java.util.Hashtable;
import java.util.Enumeration;
 
public class LoginManager implements HttpSessionBindingListener
{
             private static LoginManager loginManager = null;
             private static Hashtable loginUsers = new Hashtable();
             private LoginManager(){
                           super();
             }
             public static synchronized LoginManager getInstance(){
                           if(loginManager == null){
                                        loginManager = new LoginManager();
                           }
                           return loginManager;
             }
 
             //아이디가 맞는지 체크
             public boolean isValid(String userID, String userPW){
                           return true;   //자세한 로직은 미구현
             }
 
             //해당 세션에 이미 로그인 되있는지 체크
             public boolean isLogin(String sessionID){
                           boolean isLogin = false;
                           Enumeration e = loginUsers.keys();
                           String key = "";
                           while(e.hasMoreElements()){
                                        key = (String)e.nextElement();
                                        if(sessionID.equals(key)){
                                                     isLogin = true;
                                        }
                           }
                           return isLogin;
             }
 
             //중복 로그인 막기 위해 아이디 사용중인지 체크
             public boolean isUsing(String userID){
                           boolean isUsing = false;
                           Enumeration e = loginUsers.keys();
                           String key = "";
                           while(e.hasMoreElements()){
                                        key = (String)e.nextElement();
                                        if(userID.equals(loginUsers.get(key))){
                                                     isUsing = true;
                                        }
                           }
                           return isUsing;
             }
 
             //세션 생성
             public void setSession(HttpSession session, String userID){
                           loginUsers.put(session.getId(), userID);
                           session.setAttribute("login", this.getInstance());
             }
 
             //세션 성립될 때
             public void valueBound(HttpSessionBindingEvent event){
             }
 
             //세션 끊길때
             public void valueUnbound(HttpSessionBindingEvent event){
                           loginUsers.remove(event.getSession().getId());
             }
 
             //세션 ID로 로긴된 ID 구분
             public String getUserID(String sessionID){
                           return (String)loginUsers.get(sessionID);
             }
 
             //현재 접속자수
             public int getUserCount(){
                           return loginUsers.size();
             }
};
 
Bind_login.jsp
 
<%@ page contentType="text/html;charset=euc-kr"
             import="cookie.LoginManager"%>
 
<% LoginManager loginManager = LoginManager.getInstance(); %>
<html>
<body>
<center>
현재 접속자수 : <%= loginManager.getUserCount() %><p>
<hr>
<%
             if(loginManager.isLogin(session.getId())){  //세션 아이디가 로그인 중이면
                           out.println(loginManager.getUserID(session.getId())+"님 안녕하세요<br>"
                                                                  +"<a href=bind_logout.jsp>로그아웃</a>");
             }
             else{  //그렇지 않으면 로그인 할 수 있도록
%>
<form name="login" action="bind_login_ok.jsp">
아이디: <input type="text" name="userID"><br>
비밀번회: <input type="text" name="userPW"><br>
<input type="submit" value="로그인">
</form>
<%         }%>
</center>
</body>
</html>
 
Bind_login_ok.jsp
 
<%@ page contentType="text/html;charset=euc-kr"
             import="cookie.LoginManager"%>
 
<% LoginManager loginManager = LoginManager.getInstance(); %>
<%
             request.setCharacterEncoding("euc-kr");
            
             String userID = request.getParameter("userID");
             String userPW = request.getParameter("userPW");
 
             if(loginManager.isValid(userID, userPW)){
                           if(!loginManager.isUsing(userID)){
                                        loginManager.setSession(session, userID);
                                        response.sendRedirect("bind_login.jsp");
                           }
                           else{
                                        throw new Exception("이미 로그인중");
                           }
             }
             else{
                           throw new Exception("ID/PW 이상");
             }
%>
 
Bind_logout.jsp
 
<%@ page contentType="text/html;charset=euc-kr"%>
<%
             session.invalidate();
             response.sendRedirect("bind_login.jsp");
%>
 
Posted by 나비:D
:

[JSP] JSP 캐쉬 제거

Web/JSP
2007. 12. 18. 09:24

-jsp 에서

<%
 response.setHeader("Cache-Control","no-cache");
 response.setHeader("Pragma","no-cache");
 response.setDateHeader("Expires",0);
%>


-html에서

<meta http-equiv="Cache-Control" content="no-cache"/>
<meta http-equiv="Expires" content="0"/>
<meta http-equiv="Pragma" content="no-cache"/>



-그리고

브라우저의 도구>옵션>임시 인터넷 파일> 에서 "페이지를 열때마다"로 고쳐준다.

Posted by 나비:D
:

[JAVA] Stand-alone Persistence in a Java SE Project

Application/JAVA
2007. 12. 18. 09:20

Stand-alone Persistence in a Java SE Project

Contributed and maintained by John Jullion-Ceccarelli and Lukas Jungmann

This document takes you through the basics of developing a Java application with stand-alone persistence using Java EE 5 technology. This document uses the NetBeans 5.5 release and the Sun Java System Application Server 9.0, Platform Edition.


Expected duration: 15 minutes


Software Needed for the Tutorial

Before you begin, you need to install the following software on your computer:

  • NetBeans IDE 5.5 (download)
  • Java Standard Development Kit (JDK) version 5.0 or version 6.0 (download)
  • Sun Java System Application Server 9.0, Platform Edition (download)

    Note: While this tutorial assumes that you will have the Sun Java System Application Server installed, you can alternatively follow along by downloading just the Persistence API and using a pre-configured database connection.

Notations Used in the Tutorial

  • ${GLASSFISH_HOME}- The installation directory of Sun Java System Application Server 9.0. On Windows systems, this is usually C:\Sun\AppServer\

Tutorial Exercises

The following topics are covered below:


Setting Up the Java Application Project

The goal of this exercise is to download and open the example Java application project and configure the project's classpath to contain the libraries for Java EE 5 and the Java DB database client.

Opening the Example Project

  1. Download the example project and unzip it to a location on your computer.
  2. In Netbeans, choose File > Open Project (Ctrl-Shift-O), select the AddressBook directory, and click Open Project.
  3. Examine the project in the Projects window. The project contains a GUI front end for the program and a DBHelper.java class that populates the database with some sample data.

Configuring the Classpath

  1. Right-click the project's Libraries node and choose Add JAR/Folder.
  2. Add ${GLASSFISH_HOME}/lib/javaee.jar
  3. Add the driver to your database. If you are using the Java DB database bundled with the Sun Java System Application Server, add ${GLASSFISH_HOME}/javadb/lib/derbyclient.jar to the project's classpath.

Coding the Entity Classes

With Java EE 5 persistence, we use a persistence.xml file to define connection settings to the database. We then create entity classes that represent each of the tables in the database, and use getter and setter classes in the entity classes to work with the table data.

Creating a Persistence Unit

  1. Right-click the project and choose New > File/Folder.
  2. From the Persistence category, select Persistence Unit and click Next.
  3. Select the database connection to your application from the drop-down list. (If you are using the Java DB database, this will be: jdbc:derby://localhost:1527/sample[app on APP].) Then, for Table Generation Strategy, select Drop and Create to allow tables to be created at runtime. Leave the rest of the values at their defaults.

  4. Click Finish. The IDE creates persistence.xml and opens it in the Source Editor.
  5. In persistence.xml, switch to the XML View by clicking on the XML button in the upper left corner of the Source Editor (alternatively use Alt+Shift+Right or Alt+Shift+Left). Make sure that the appropriate password for your database connection is supplied. If you are using the JavaDB, the default password is app: <property name="toplink.jdbc.password" value="app"/>

Creating the Address Entity Class

We will now create the Address entity class. When you create the entity class, the IDE adds the @Entity annotation to define the class as an entity class. After we create the class, we will create fields in the class to represent the data that we want in our table.

  1. Right-click the project and choose New > File/Folder.
  2. From the Persistence category, select Entity Class and click Next.
  3. Type Address for the class name, addressbook for the package, and leave the primary key type as Long. Click Finish.

    When you click Finish, the entity class Address.java opens in the Source Editor. In the Source Editor, do the following:
  4. Add the following field declarations to the class: String street; String city; String country;
  5. Choose Refactor > Encapsulate Fields from the right-click menu in the Source Editor. This will allow you to switch the access mode for the fields to private, as well as generate getters and setters for each of the fields. Leave Fields' Visibility at private, and Accessors' Visibility at public. Make sure that getter and setter checkboxes are selected for all fields. Click Next.
  6. In the Refactoring tab of the Output window, click Do Refactoring. The IDE adds the getter and setter methods for the fields and changes the visibility of the fields to private.
  7. We now want to change the name of one of the columns that will be created in our database table: instead of id, we want our column to be called AddressID. To do this, we can use annotations to specify the name of the generated column by adding the following annotation to the id field declaration. Add the following line to the id field declaration in Address.java: @Column(name="AddressID")
  8. Press Alt-Shift-F to generate an import into the class for javax.persistence.Column.

    Your field declaration should now look like this:

Creating the Person Entity Class

We will now create the entity class Person representing the PERSON table in our database.

  1. Right-click the project and choose New > Entity Class.
  2. Type Person for the class name, addressbook for the package, and leave the primary key type as Long. Click Finish.
  3. Create the following field declarations: String surname; String name; Address address;
  4. Choose Refactor > Encapsulate fields to switch the access mode for the fields to private and generate getter and setter for the fields. Again, leave Fields' Visibility at private and Accessors' Visibility at public. Make sure that getter and setter checkboxes are selected for all fields. Click Next.
  5. In the Refactoring tab of the Output window, click Do Refactoring. The IDE adds the getter and setter methods for the fields and changes the visibility of the fields to private.
  6. Add the following annotation (in bold) above the id field declaration: @Id @GeneratedValue(strategy = GenerationType.AUTO) @Column(name="PersonID") private Long id;
  7. Add the following annotation (in bold) above the address field declaration. If you place the cursor in the field declaration you can use the source editor hints to generate the annotation for you: @OneToOne(cascade=CascadeType.ALL) private Address address;
  8. Change the body of the toString method as follows: public String toString() { return surname + ", " + name + ": " + address.getStreet() + ", " + address.getCity() + ", " + address.getCountry(); }
  9. Press Alt-Shift-F to generate any missing import statements.

Editing the DBHelper Class

The DBHelper class is used by the program to interact between the database and the front-end user interface. The class already has a createPersons method that provides data for the database. We need to create methods that enable us to populate the database, insert a new person, and get all entries.

  1. Double-click DBHelper to open it in the Source Editor.
  2. Right-click in the Source Editor and choose Persistence > Use Entity Manager.

    The IDE adds the following field to the class: private static EntityManagerFactory emf = Persistence.createEntityManagerFactory("AddressBookPU");

    and adds the following persist method:

    public void persist(Object object) { javax.persistence.EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); try { // TODO: // em.persist(object); em.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); em.getTransaction().rollback(); } finally { em.close(); } }

    The following import statement is also added to the class:

    import javax.persistence.Persistence;
  3. We need to change the name of the persist method created by the Entity Manager so that it corresponds to the add method used elsewhere in our project. Make the following changes (in bold) to the persist method that was just created: public static void add(Object object) { javax.persistence.EntityManager em = emf.createEntityManager(); em.getTransaction().begin(); try { em.merge(object); em.getTransaction().commit(); } catch (Exception e) { e.printStackTrace(); em.getTransaction().rollback(); } finally { em.close(); } }
  4. Now, add the following methods to the class: public static void setUpDB() { for (Person p: createPersons()) { add(p); } } public static List getData() { return emf.createEntityManager().createQuery("SELECT p FROM Person p").getResultList(); } private static EntityManagerFactory emF = Persistence.createEntityManagerFactory("persistence"); private static EntityManager em = emF.createEntityManager();
  5. Create the following methods in the class: public static void setUpDB() { EntityTransaction et = em.getTransaction(); et.begin(); for (Person p: createPersons()) { em.persist(p); } et.commit(); } public static void add(Object o) { EntityTransaction et = em.getTransaction(); et.begin(); em.persist(o); et.commit(); } -->

Summary

In this exercise, you created a persistence unit and added several entity classes enabling the database to interact with the front-end user interface. You then configured the persistence unit to create tables at deploy time.


Running the Project

Now let's start the database server, build the project, and run the GUI interface.

  1. Start your database server. If you are using the Java DB database, choose Tools > Java DB Database > Start Java DB Server.
  2. Right-click the project node and choose Run Project. The following form displays all of the data in the table:

  3. Choose Menu > Add Person to add a person to the database. Fill in some sample data, as shown below, then click Add.

    The data is added to your database, and you will notice the changes are updated immediately in the Address Book window.

Summary

In this exercise, you set the necessary runtime options and tested the program by displaying the data in the table and adding a new entry.




Next Steps

To send comments and suggestions or get support, please use the feedback link above. To keep informed on the latest developments on the NetBeans IDE J2EE development features, join the nbusers@netbeans.org mailing list.

Posted by 나비:D
:

DBHelper Plugin User’s Guide

SQL
2007. 12. 18. 09:18
http://ca.geocities.com/davidhuo2003/dbhelper/userguide.htm


DBHelper Plugin User뭩 Guide

David Huo

What is DBHelper plugin. 1

Why is it developed. 2

Features. 2

License. 3

Getting started. 3

Installation. 3

New file types. 3

SQL ?Syntax highlighted SQL Script file. 3

DIA ?The Database Diagram File. 4

Configure the Database Profile. 4

Browsing Database Meta Information. 8

Find Usages of a table or stored procedure. 12

View/Update Table Data. 13

Edit SQL Script 14

Using the SQL Code Completion. 15

Run SQL Script 16

Save SQL Script 17

View Database Schema in Diagrams. 18

Advanced Topics. 20

Database Meta Data is presented as JavaBeans. 20

Extending DBHelper with Velocity Templates. 20

How the templates are organized. 20

How to write Velocity templates for DBHelper 22

Some useful templates. 23

Extending DBHelper Meta Information using Java. 23

Adding meta-data in the JavaBean class using Property annotation. 23

Implementing IMetaProvider interface. 24

How to build the plugin jars: 24

Contact information. 25

Send your questions and comments to: 25

dbhelper@gmail.com.. 25

 

What is DBHelper plugin

DBHelper is an IDEA plugin, which aims to extend IDEA IDE to support SQL language programming and database schema desgin. The current version is developed and tested under IDEA 5.1.2 and IDEA 6.0.1. The new builds are tested under IDEA 6.0.1 now.

Why is it developed

As an IDE for Java development, IDEA has done a great job. However many projects or applications are backed with databases. When the IDEA users are working with SQL programming and database, they have to find other solutions. I don뭪 know how many times that I wanted a nice integrated database tool which could come with IDEA and offer some nice features, such as SQL code completion, syntax highlighting and so on. I decided to write a plugin to add SQL programming support in IDEA. This is the preview release and I have planned many features to be added in the future. The following features are available in this release.

Features

1)      Adding two new file types IDEA can recognize:

a.       SQL ?The SQL script file

b.      DIA ?The database schema diagram file

2)      Basic syntax highlighting ?Supporting keywords, single line comments, /** **/ style multi-line comments, strings and number. The keyword is updated dynamically based on the database you are working with.

3)      Code completion:

a.       Supporting basic completion: Hit Ctrl + Space lists all the objects in the current database and narrows down as the user typing

b.      Correlation name completion: When the user hits ?? it will resolve the correlation name and pops up the suggestions, such as catalogs, schemas, table columns and stored procedures. It can also resolve SQL correlation name, temp tables, declared variables and parameters (works for SQL iAnywhere or ASE T-SQL format)

4)      Run SQL script inside IDEA editor ?At any time, the user can highlight a block SQL script or run the whole SQL script in IDEA editor and the result will show in the DBHelper output panel.

5)      View Database schema as diagram ?At any time, the user can select multiple tables or a type of tables and view the schema in a graphical diagram. The diagram can be saved as DIA format or copied as image.

6)      Update table data ?The user can view the data of any table and insert/delete/update the table data.

7)      Support multiple databases via standard JDBC interface, tested databases are:

a.       Sybase SQL Anywhere (tested on version 9.x)

b.      Sybase ASE (tested on version 12.x)

c.       MySQL (tested on version 5.x)

d.      SQL Server (tested on version 2000)

e.       Oracle (tested on 9i)

Extra database meta data can be supported by adding plugin jars to DBHelper (Implementing IMetaProvider interface, see ASA user meta extension sample)

8)      It is designed to be extended using Velocity templates. (Velocity is an open source apache project for generating text content based on a simple template). Uses can add templates to generate customized content based on the database meta data, such as generating XML data based on resultset, or JDBC call to retrieve the resultset from the database. There are some templates come with this release as examples.

9)      SQLConsole is newly added to support users that primarily don뭪 write lots of stored procedures and only want to run some simple queries inside IDEA. Users can open SQLConsole in DBOutput tool window and run any SQL queries. Of course syntax highlighting and SQL code completion are also available in the SQLConsole.

10)  Query Manager: Users can create new or update queries in DBOutput tool window Saved Queries tab.

License

젨젨젨젨젨?The plugin is under Apache License and free to use.

Getting started

Installation

The plugin consists of three jar files and they are packaged as a zip file. To install it, the user needs to unzip the zip file to %IDEA%\plugins and restart IDEA.

 

After restarting IDEA, the user should see two new tool windows: DBHelper is on the left side along with project, structures. DBOutput is on the bottom along with ?span class=SpellE>ToDo?and 밊ind?tool windows.

 

The DBHelper tool window is a panel with three tabs:

1)      DBTree ?A tree view of the databases structures

2)      Category View ?A categorized view of selected database with quick search feature

3)      Settings ?A tab to configure DBHelper, such as databases, template locations

 

The DBOutput is a tabbed panel to display SQL resultset, it has two build-in tabs:

1)      Console ?It displays the SQL statement is running and the time it used

2)      QueryManager ?It holds all the saved query and the user can select or search the saved query and run it again

If the user runs a SQL statement that generates resultsets, the resultsets will be added to the output panel as a new tab.

New file types

With DBHelper installed, IDEA can work with these two new file types:

SQL ?Syntax highlighted SQL Script file

The user can edit/save SQL file as other file types in IDEA main editors (Not in a small separate panel). SQL code completion is integrated in the SQL editors.

 

DIA ?The Database Diagram File

The user can generate DIA files by reversing meta data from the connected database and save it as DIA file format or layout the diagram and copy the content as an image. The image can be pasted into other document editors, such as MS Word. Adding new tables and changing the database schema are planned in future release.

 

Configure the Database Profile

To get started, the user needs to configure the database profile that he/she will work with.

1)      Go to the Settings tab in the DBHelper tool window:

2)      Right-click the databases icon in DBTree and select 밃dd Database? It will bring up the database profile editor:

 

3)      The user can click the 밄rowse?icon beside the driver dropdown-listbox to add vendor JDBC jar files. 밬se Full Object Name?tells DBHelper how to generate database object names, such as table and stored procedure names. If it is checked, DBHelper will use full name, which is catalog.schema.object to reference an object; otherwise only the object name will be used. Depends on the URL or the database the user is using, you should uncheck/check this option. For example, if you use MySQL 5, the URL can be either: jdbc:mysql://localhost/ ?without a database name or jdbc:mysql://localhost/test ?with a database name. If you don뭪 give the database name, you have to check 밬se Full Object Name?option to get the access to the object. If the database name is specified in the URL then you can uncheck this option to make the object names shorter. Another reason is that some database doesn뭪 support using catalog in the database name but it does report the object belongs to a catalog, such as H2Database. In this case, you have to give the URL with database specified and uncheck this option. This option is changeable at any time.

4)      If you think adding extra jar files for each database profile is very cumbersome. You can add global jar files in the 밪ettings?tab in the DBHelper tool window or in IDEA Settings dialogbox and select DBHelper.

 

5)      The user should specify user, password fields as well. Extra options can be defined in the Additional tab area, and these values will be added as connection properties.

 

6)      Click OK to save the database profile. At any time the user can click the database profile item in the DBTree panel and select 밇dit Database Profile?to edit it.

 

7)      Other fields: After the database profile is saved, the user can click the database profile and view the properties of the profile in the property panel:

 

 

젨젨젨젨젨?There are some other fields that the user can change:

a.       maximumRowsToRetrieve: To specify maximum rows DBHelper will retrieve for a query.

b.      metaProvider: The user can write its?own meta extension and add extra nodes under each database node in the DBTree view and Category view. The extension should be packed as jar files and added in the jars field. Once the jar files are added, clicking the metaProvider field will bring up all the extension classes, which implements the IMetaProvider interface.

c.       procedureSyntaxQuery: To specify a query that returns the stored procedure syntax. The query is expected as a valid Velocity template and returns the stored procedure body as the resultset. The procedure name can be referenced as $name in the template. For example, this query returns the a given stored procedure syntax for MS SQL Server:

EXEC sp_helptext $name

젨젨젨젨젨젨젨젨젨젨젨?Note: Defining this field can help DBHelper뭩 find usage function work better because it can search stored procedure bodies to find table or stored procedure references.

 

Browsing Database Meta Information

Database meta data are presented as a tree view in the DBTree tab and list view in the category view in the DBHelper tool window. Under the treeview or listview, there is a property view panel below it shows the current selected object properties. The property panel can have two types of views: 1) Sortable view: the user can click the title of the columns to sort the data 2) Categorized view: the user can view the information based on categories and close/expand any of the categories. DBHelper uses all standard JDBC database meta API to retrieve the meta data. If the property is an array field, clicking the ?button will bring up a dialog box to show the elements in the array field, for example, columns in a table or indexes in a table are presented in this way.

 

DBTree view

 

Category view

 

 

Viewing a property of array type.

 

The user can select 밪et Filter?in the table type folders or stored procedure folder to specify filters based on catalog and schema. The sub-items will be filtered based on the selected items in the filter setting dialog box.

 

Find Usages of a table or stored procedure

The user can search the references of a given table or stored procedure in the database by right-clicking a table or stored procedure and select 밊ind Usages?

 

 

Check the search options and click search. DBHelper will start a search thread and search the references for the given object and show a search result in the DBOutput tool window:

 

The search result will tell the user the reference object name, type and line number (If it is a stored procedure). On the right-hand there is a syntax highlighted code viewer to show the stored procedure syntax and the referenced line is marked in red.

 

Note: It is important for the user to specify the procedureSyntaxQuery in the database profile so that the find usage can search stored procedures.

View/Update Table Data

If the resultset is generated by 밮iew table data?menu action, the resultset is editable. The user can update/insert/update multiple rows and synchronize with the back-end database after he/she clicks the 밇dit?icon.

 

If the resultset is generated by a typed SQL command, the resultset is read only by default. If the user knows the resultset columns are from only one table. The user can click the edit button and specify the table to update.

 

The result panel also shows how many rows are in the resultset on the right-up corner. If the user clicks the resultset rows button, it will show a resultset metadata dialog showing column count and data type of each column. The user can check/uncheck the first column to hide/show the columns in the resultset.

 

Note: If some columns are filtered by the user, it also affects some templates running results. For example, 밅opy as Inserts?will only generate the selected columns in the insert statements, similar as 밅opy Row?and ?span class=SpellE>ToXml?templates. If the user wants to write any resultset related templates, he/she should reference these existing templates to see how to take the filter account.

Edit SQL Script

The user can create new SQL file or open existing SQL file in the same way working with Java files in IDEA. Each SQL file editor is associated with a database profile so that the code completion module knows from where to retrieve the database meta-data. To associate a database profile to the SQL editor, the user needs to select the menu: Tools->Select Database:

 

I recommend the user to connect the database first and then select the database profile. If the database is connected, the keywords in the SQL editor will be updated based on the keyword list returned by the database meta-data. If the SQL is not associated with any database profile or the database is not connected, the code completion will only suggest the SQL92 keywords.

 

Note: This select database dialog box will show up only when the current active editor is holding a SQL file.

 

Using the SQL Code Completion

DBHelper supports two types of code completion:

1)      Basic completion: At any time the user can hit Ctrl + Space to popup the completion list. The list includes: keywords, catalogs, schemas, tables, views, stored procedures, and system functions. The items are narrowed down as the user is typing. This isn뭪 any suggestions if the users hit the hotkey in SQL comments and strings.

2)      Correlation completion: If the user hits ??after an identifier, DBHelper will try to resolve the identifier to see if it is catalog, schema, table or temp table. It will suggest corresponding child items if the identifier is resolved successfully. For example, it will pops up column list if the identifier is a table.

3)      Complete last completed table뭩 columns: DBHelper remembers the last table the user used from the suggestion list and Ctrl + L can bring the column list of the table.

DBHelper resolves the 밻?is a correlation name of the employee table and brings up the columns of the employee table.

 

The suggestion list is a multi-selection table; the user can select multiple items by clicking with Ctrl key down and the completion items will be inserted as item1, item2 ?/p>

 

The bottom bar of the completer windows shows the database the SQL editor is currently associated with.

 

Hint: When the completion list is showing, the user can hit tab key to drill down to the lower level of the current selected item, for example, if the current selected item is a table, the tab key will change the list items to the columns of the table.

 

Hint: When the completion list is showing, hit Ctrl + A will select all items in the list and the completion will skip the ??item if there are multiple items are selected.

 

Run SQL Script

At any time, the user can run the highlighted a block of SQL script or the whole SQL script by pressing Ctrl + F10. The SQL statement and execution time will be displayed in the DBOutput tool window console tab and the resultset will be added as a new tab in the DBOutput tool window if there is any.

 

The user can also select 밢pen a SQLConsole?in the DBHelper menu to open a SQLConsole in the DBOutput tool window. It is a split panel. The resultsets will be shown as tab pages on the left-hand side and a syntax highlighted SQL code editor is on the right-hand side. Press Ctrl-Enter to run the current SQL statement and use the database dropdown-list to select the database you want to work with.

 

Note: When there is a SQL statement still running, the user can뭪 run another SQL statement. DBHelper will tell the user there is one statement running and the user has the choices: 1) Wait until it finishes 2) Discard the current one and run the new SQL script

 

Save SQL Script

By clicking the 밪ave Query?icon on the resultset tab, the SQL script can be saved and run again later. The saved queries are displayed in the 밪aved Queries?tab in the DBOutput tool window. By clicking the title of each column, the queries can be ordered in ASC or DESC order. The user can also click the edit icon to edit the saved query in a query editor which is similar as a SQLConsole except the database dropdown list is disabled if the query뭩 database name is found in the current database profile list. The user can create new queries by clicking the new query icon.

View Database Schema in Diagrams

If the user selects multiple tables in the DBTree view or Category view, there is an item on the right-click menu saying: 밮iew Tables Diagram? Click this menu item will generate a graphical view of these tables schema. The action will also add those tables that have relationships with these selected tables in the diagram.

 

 

Tables are automatically laid out based on the relationships and the size and locations of the object can be adjusted by dragging the icons. The diagram is named based on the database. The user can save it or save it as anther file name. There are also functions to help finding the object in a large diagram ? 밊ind Object?right-click menu item can bring up the following dialog box and the user can type the search condition and locate the object.

 

Advanced Topics

Database Meta Data is presented as JavaBeans

All the database meta-data objects, such as Table, Column, Primary Key, Foreign Key, Index, Procedure, Procedure Parameter/Result Column and so on are all JavaBeans. Child objects are collected as one-dimensional arrays. For example, Table.getColumns() returns an array of Column objects.

Extending DBHelper with Velocity Templates

One important benefit that DBHelper offers is that it presents the database meta-data in JavaBean format and the user can use Velocity Templates to access the meta-data information and generate proper content for its own needs.

How the templates are organized

The user can specify the folder where all the templates are stored in the Settings tab in the DBHelper tool window:

 

DBHelper looks for a meta-file called templates.xml under this folder. The meta-file describes all the templates under this folder.

<templates>

<template name="Generate SQL script for these tables" database="ianywhere" target="tables" file="asa/SQLAnywhere.vm" />

<template name="Update Statement" target="table" file="asa/updateTable.vm" />

<template name="Update Statement (ASA)" database="ianywhere" target="table" file="asa/updateTable.vm" />

<template name="Copy Row" target="resultset" file="copyRow.vm" />

<template name="Generate JDBC Call" target="procedure" file="jdbcCall.vm" />

<template name="JDBC Call for this resultset" target="resultset" file="jdbcCallforResult.vm" />

<template name="Parameter Test" target="table" file="test_params.vm" />

<template name="To XML" target="resultset" file="toXml.vm" />

</templates>

 

Each template entry describes a template file. The meaning of these attributes is described in the following table:

Attribute Name

Meaning

Required

name

The name of the template and also it is the menu item text in the popup menu to run this template

Y

database

The target database that this template is used for. The value must be found in the JDBC driver뭩 class name. For example ?span class=SpellE>ianywhere? is part of ASA JDBC driver class name.

N

target

The object type that the template expects as the render parameter $target. Possible values:

1)      tables ?the template will receive an array of Table object as $target value

2)      table ?$target is the selected table object

3)      procedure -- $target is the selected stored procedure

4)      resultset -- $target is a JTable holding a resultset using ResultModel table model.

Y

file

The template file name.

Y

 

How to write Velocity templates for DBHelper

Here is an example of generating XML data based on the selected rows in a resultset tab in the DBOutput tool window:

1) Add this line in the templates.xml

<template name="To XML" target="resultset" file="toXml.vm" />

2) The template looks like this:

?/span><result>

#set($rows = $target.getSelectedRows())

#set($cols = $target.getModel().Columns)

#foreach($row in $rows)

#set($colId = 0)

<row #foreach($col in $cols )

#set($t = $col.type)

#set($value = $target.getValueAt($row, $colId) )

$col.name="#if( $target.getValueAt($row, $colId) )$value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;")#end" #set($colId = $colId + 1 )#end#set($cols = $target.getModel().Columns)>

#end

</result>

 

The output will be put in clipboard as this:

<result>

<row dept_id="100" dept_name="R &amp; D" dept_head_id="501" >

<row dept_id="200" dept_name="Sales" dept_head_id="902" >

<row dept_id="300" dept_name="Finance" dept_head_id="1293" >

<row dept_id="400" dept_name="Marketing" dept_head_id="1576" >

<row dept_id="500" dept_name="Shipping" dept_head_id="703" >

</result>

 

Sometimes, the user wants to get extra input before the template is running, then the user should define the template parameter in this format:

$runtime_xxx(default value). If you need to use the same parameter multiple times, there is only one need to specify the default value and the one with default value should be put in velocity comment ##.

 

For example, if the user adds $runtime_tableName in the template file and invokes the template, the following dialog box will show up and asks for the value of tableName:

 

The template files are monitored and changing the template will take effect without restarting IDEA. If the user changes templates.xml, reset the template folder in the Settings tab will force DBHelper to reload all templates.

Some useful templates

There are some templates come with this release as examples:

Name

Target

Description

toXml

resultset

Copy the selected rows in the resultset in XML format

Copy as Inserts

resultset

Copy the selected rows in the resultset as insert statements

Copy Row

resultset

Copy the selected rows values

GetAsSQLCursor

resultset

Generate a cursor statement to go through the resultset

JDBC Call for this resultset

resultset

Generate JDBC call to retrieve the resultset

Generate SQL script for these tables

Tables

Generate SQL script to create tables and references based on a Diagram (ASA syntax)

 

Extending DBHelper Meta Information using Java

If the user wants to see some database specific meta-data information, such as users, groups, triggers and so on, he/she needs to write an extension, which implements IMetaProvider interface. The database objects should be presented as JavaBean objects without any collection data type in it. Collection of data should be in standard array data type.

Adding meta-data in the JavaBean class using Property annotation

DBHelper provides an Annotation interface called: Property to add meta-data into the database JavaBeans so that they can be displayed more efficiently in the property panel:

 

public @interface Property {

젨?String editor() default ""; // specify the bean editor class name for this property

젨?String name() default "";

젨젨 int ordinal() default -1; // specify the ordinal in the JDBC resultset to map the value to

젨?boolean expose() default true; // specify if the property editor should display this property

젨?String propertyName() default "";

젨?String mappedName() default ""; // specify the JDBC resultset column name to map the value to

젨?String category() default ""; // specify the category name for the categorize view

젨?String className() default "";

젨?LabelTag[] tags() default {}; // specify the tag values for the bean editor

젨?String desc() default "";

젨?boolean xmlCDATA() default false;

젨?boolean xmlAttr() default true;

젨?String defaultClassNames() default "";

젨?boolean editable() default false; // specify if it is editable using property editor

}

 

If the user gives ordinal or mappedName in the bean class write methods. The mapping from a JDBC resultset to the bean objects can be done easily by calling:

static <T> List<T> rsToList(ResultSet rs, Class<T> theClass)

in BeanUtils class.

Implementing IMetaProvider interface

public interface IMetaProvider {

젨?List<IDBNode> getNodes(AbstractDBObject.DatabaseNode db);

}

 

DBHelper will give the database node the extension will be added on. The easiest way to implement IDBNode interface is to use AbstractDBObject and overwrite populateChildren() method to populate all the child nodes.

 

Note: The user must call setParent(IDBNode n) for each node to maintain the proper parent/child chain.

 

For more information about adding extension nodes, please see the ASAUser example comes with this release.

How to build the plugin jars:

1)      Download the source code and modify the dbhelper.properties file to use proper IDEA install folder

2)      ant -f DBHelper.xml to build dbhelper.jar

3)      ant -f DBHelper.xml dist to build the plugin zip file

Note: There other two jar files are JDK XML stream API jar files. If you use JDK 1.6, you don뭪 need these two jar files.

 

Contact information

Send your questions and comments to:

dbhelper@gmail.com

 

1
Posted by 나비:D
:

[JAVA] 기본!

Application/JAVA
2007. 12. 17. 20:31

자바라는 언어는 다른 프로그래밍 언어와 마찬가지로 컴퓨터와 대화할수 있는 수단이다.

c 는 언어이고 자바는 인터프리터 언어이다.


자바의 특징

1. 이식성이 높은 언어

   한번 코딩되어 컴파일된 상태의 클래스 파일은 다시 수정하지 않고도 JVM이 설치되어 있는 시스템에서는 실행가능하다.

   JVM(Java Virtual Machine) 자바 가상머신 ; 인터프리터의 기능을 수행하는 프로그램.

2. 외부 포인터를 제거하고 내부적인 포인터 사용

    c,c++의 겉으로 드러나는 포인터를 제거하고 내부적으로 객체의 메모리 할당시에 무조건 동적으로 메모리를 할당시키는 방식을 취함.

3. 완벽한 객체지향적 언어

플랫폼에 독립적 (분리로봇으로 개념정립) ; 분리되어도 작동하는데 이상없다.


J2SE JDK (Java2 Standard Edtion Java Developement kets) : 자바 개발툴로 compiler를 포함하고 있다.


자바프로그램을 위한 필수 요소

1. Source를 만들수 있는 텍스트 에디터 (텍스트로 작성이 가능한 모든 에디터 프로그램 가능)

    ex. 메모장, editplus, Eclipse, Ultra Edit 등등

2. 자바 개발툴 즉 컴파일러 : JVM이 포함되어 있다.


※ 자바의 모토 : Write Once, Run Anywhere. 운영체제와 상관없이 자바 프로그램이 실행된다.

    단, 운영체제내에 JVM이 설치되어 있어야 작동 가능하다는 전제조건 존재.


자바 프로그램을 작성하기 위해서 우선 Sun사에서 JDK 1.4 버젼을 다운로드 받아 설치한다.

원활하고 효율적인  사용  위해 환경 변수를 설정한다.


※ 환경변수 설정

시작 - 설정 - 제어판 - 시스템 - 고급 - 환경 변수 클릭

시스템 변수 아래 편집 클릭

변수이름 : path

변수값으로 자바 컴파일이 있는 경로를 써넣는다.


환경변수를 설정하는 이유는 앞에서 설명한바와 같이 효율적인 사용을 위한것이다.

Path를 꼭 설정하지 않고 사용해도 컴파일과 실행에는 지장이 없다. (단, 컴파일러가 위치한 곳에서만 컴파일러 및 실행 가능)


자바 Version

Java 1.1

Java 1.2 ~ 1.4 : Java2라고 명명

Java 1.5 : Java5라고 명명

Java 1.6 : Java6라고 명명


☞ 버젼에 대한 세부소개

Java 1. 4. 2_6

4라는 숫자는 획기적인 변화가 있을때 증가한다. 1.2와 1.4는 전혀 다르다.

2는 업그레이드를 뜻하고, _ 다음에 있는 6이라는 숫자는 미세한 업그레이드가 있을시에 추가된다.


텍스트 파일은 컴퓨터가 있을수 없다. 반드시 0과 1의 이진코드인 기계어로 컴파일을 해야 실행 가능하다.

jdk의 bin 폴더에 javac라는 컴파일러를 통해 텍스트로 작성된 .java 파일이 컴파일된다.

컴파일이 되면 0과 1의 조합인 클래스파일 .class 이 생성된다.

JVM인 java로 자바 파일을 실행하면 프로그램이 실행된다.


Java Coding시 유의사항

1. 클래스명과 파일명이 같아야 한다.

2. Java에서는 대, 소문자를 엄격히 구분한다.

3. 한문장 끝에는 반드시 ;(세미콜론)을 붙인다.

4. () {} 을 주의해야 한다.


Java 프로그램의 기본 형식

class 클래스명 {

         public static void main(String[] args) {

                  System.out.println("First Java Program");      

          }

}


▶ System.out.println(); 은 " " 안에 있는 문자를 화면에 출력하라는 뜻.


Java 의 핵심기술

Java SE (Java Standard Edition) : 기본

Java EE(Java Enterprise Edition) : 기업형으로 대형 프로젝트

Java ME (Java Micro Edition) : 주로 휴대폰, 작은 시스템


jdk 폴더내에 jre, lib  => 참조


접근 지정자

private : 클래스 내부에서만 사용 가능, 다른 클래스에서는 이 멤버 사용 불가능

public : 모든 클래스가 접근 가능

default (friendly, package) : 같은 패키지 안의 클래스가 접근 가능

protected : 같은 패키지 안의 클래스가 접근할수 있고, 다른 패키지에 있는 자식 클래스도 접근가능(상속 관계에 있는 클래스)


클래스 앞에 올수 있는 접근 지정자

public

default(friendly)


은닉화(또는 캡슐화) : 다른 클래스에서 멤버변수에 직접적으로 접근하는것을 막는것.


객체는 자신의 데이터와 내부에서 일어나는 일은 외부로부터 숨기고, 단지 외부에는 객체 내부와 통신할수 있는 인터페이스 제공

외부에서는 객체의 인터페이스만을 통해 그 객체를 사용할수 있게 하는것.


오버로드(Overload)

같은 이름을 가지는 멤버 메소드를 정의하는것


생성자 : 객체를 만드는 순간에 호출되어 실행되는 특수한 메소드

ex) Ex e =  new Ex();

멤버 변수를 초기화 하지 않으면 기본자료형은 0을, 레퍼런스는 null을 기억하게 된다.


생성자의 이름은 클래스의 이름과 동일하고 리턴형이 없다.

컴파일러가 만들어주는 생성자를 default 생성자라고 함.

디폴트 생성자는 매개변수가 없고 몸체가 비어 있다.

class Ex {

     Ex() { }

}


this()

생성자에서 오버라이드된 다른 생성자 호출 가능.

생성자 호출 : this(), this(a), this(a,b)


this() 호출의 제한

생성자의 실행은 다른 처리보다 우선적이므로 this()는 {}안에서 맨위에 있어야 한다.


생성자는 객첼를 생성하기 위해서만 사용되기 때문에 일반메소드는 객체를 생성한후에 사용하는 메소드이므로 this() 를 일반 메소드에서 호출 할수 없다.


객체의 생성과 소멸

객체가 필요에 의해 생성되었다면 반대로 언젠가는 소멸하게 된다.

소멸이라는 말은 메모리에서 제거된다는 뜻.

객체의 생성과 소멸 시기를 정확히 알아야만 객체를 잘 활용 가능.


static

데이터 값의 공유를 위해 선언하는 공간 (멤버 필드로만 가능)

클래스 이름으로 접근 가능

객체 발생 전 메모리 할당


static 초기화 영역

static 멤버 필드의 값을 초기화 하기 위한 영역

예) static { 초기화 구문 }


static 메소드 : static 필드 컨트롤 목적


class Ex_1 {

     private String name;

     private double don;

     private static float iyul;

    static {

           iyul = 0.04f;

     }


     public Ex_1 (String name, double, float iyul) {

           this.name = name;

           this.don = don;

           Ex_1.iyul = iyul;

      }

      public void disp() {

          System.out.println("name" + name);

          System.out.println("don" + don);

          System.out.println("iyul"+ iyul);

      }

}

public class Ex {

      public static void main(String[] args) {

          Ex_1 ex1 = new Ex_1();

          ex1.disp();

          System.out.println();

          Ex_1 ex2 = new Ex_1();

          ex1.disp();

          ex2.disp();

    }

} 

static 프로그램 시작시에 실행된다.

함수 선언
데이터형이 필요
함수의 데이터형 = 반환값
받으면 준다.

ex1=fun(ex1); // 함수(function) 호출 Call by function
ex2=fun(ex2);
ex3=fun(ex3);
// fun(인자);

int[] func(int[] ex) {
 내용부;
 return ex;  
 }


예제

int money=2000;
int month=13;
int result1=(money/month)-((money/month)*0.15);

money=3000;
int result2=(money/month)-((money/month)*0.15);
money=4000;
int result3=(money/month)-((money/month)*0.15);
money=5000;
int result4=(money/month)-((money/month)*0.15);

int result6 = fun(6000);
int result7 = fun(7000);
int result8 = fun(8000);
int result9 = fun(9000);

int fun(int money) {
 int month=13;
 int result5=(money/month)-((money/month)*0.12);
 return result;
}


main() 프로그램 시작시 호출 - 고정


예제2
int a=4;
int b=5;

int c= plus(a, b);
a=plus(3, 3);
//float d = plus(3,3); 불가
//btye d =plus(3,2); 불가
int plus(int a, int b) {
 return a+b;
}

호출한 데이터형 그대로 받는다.


반환형 : 함수가 만들어내는 결과치가 가르키는 데이터형
함수명 : 변경 가능

반환형 함수명(인자) { // 인자는 개수에 상관없다. 반환형은 한개다.
 선언부;
}
int a(){ }



public static void main(String[] args) { } // main() method(함수) 프로그램 시작시 제일 먼저 호출

void : 반환값이 없다. return 하지 않는다.

함수에 따라 값이 없는 경우가 있다.

사용자 정의 함수 : 임의로 만들어진 함수

class 이름 { }

int ys=10;
int yb=2;
int cb=2;
int cs=0;

변수들을 묶어놓는다.

구조체 : 관련있는것끼리 묶어 놓은것 (class)
영희 {
 int s=10;
 int b=10;
}

철수 {
 int s=0;
 int s=2;
}

영희.s // . 참조
철수.s


class YoungHee {
 int apple=10;
 int peak=2;
}

class ChulSu {
 int apple=0;
 int peak=2;
}

YongHee yong = new YongHee();
ChulSu chul = new ChulSu();

yong.apple= yong-2;
chul.apple= chul+2;


레퍼런스변수 : 클래스를 가지는 변수

구조체 데이터형의 제약이 없다.

class Man{
 int sa=0;
}

Man y= new Man();
y.sa=2;

객체에 대한 정의  : 클래스 (함수도 가질수 잇다.)
객체(Object or instance) 정의에 의해서 만들어진것.

class test {
 public static void main(String[] args) {

  Round09_01  R1 = new Round09_01(); // 객체 생성
  R1.sub[0]=100, R1.sub[1]=20;
  R1.sub[2]=10, R1.sub[3]=40;
  R1.calc();
  System.out.print(R1.avg);
 }
}

String은 클래스이다.(Wrapper 클래스)

문자열

wrapper 클래스 : 자료형을 효율적으로 관리함과 동시에 완벽한 은닉화를 추구하기 위해 만들어진 자료형
대체 클래스
int  Integer
float Float
char String

명명 규칙
변수명의 첫글자 소문자
첫글자 대문자 클래스명

String s = new String( {'1','2','4} );
String s = "123"
s.substring(0,2);

String a = "123";
a.length();

String s1 = "123";
String s2 = "123";

boolean a=s1==s2;
s1.equals(s2); // String 클래스 비교

레퍼런스 변수는 주소만 가진다.

String s ="abc"; // " " String 나타내는 상수
s= new String(1); = "1"

"123" + "456" =>  문자열 합침 = "123456"

int a=32;
String s="56";
s=s+a; // 문자열 하나라도 있으면 String 56
s=32+a; // 에러

s=s+a+2+a; // "5666"


int val=125;
Integer ival = new Integer(val);
s= ival.toString();


System.out.println();
. : 참조
System class
out class
println() method
print() method

System.in.println();

int a = System.in.read();
System.out.println(a);


s=" " + val; // "125"

Posted by 나비:D
:

[JAVA] dbhelper

Application/JAVA
2007. 12. 17. 20:28
WAS는 weblogic6.1이고요
오라클 8.1.7 버젼을 사용하고 있습니다.
보시다시피 DataSource 를 통해 커넥션을 처리하고 있습니다.

1. 첫번째 클래스
아래 주요 사항중에 DataSource , Connection
객체가 멤버변수로 선언이 되어 있다는점
그리고 getConnection() ,freeConnection() 메소드가
동기화처리를 안하고 있다는 점입니다.

다음 클래스가 어떻게 수정되야 좋을지 조언 부탁드립니다.

public class OracleAdminConnectionManager{

static final String ORACLE_DATASOURCE = "java:comp/env/jdbc/OracleAdmin";
private DataSource ds = null;
Connection conn = null;

public OracleAdminConnectionManager(){

Context ctx = null;
try{
ctx = new InitialContext();
if(ctx == null)
ds = (DataSource)ctx.lookup(ORACLE_DATASOURCE);

}catch(NamingException nx){
nx.printStackTrace();

}
}

public Connection getConnection(){
try{
conn = ds.getConnection();
}catch(Exception ex){
ex.printStackTrace();
}
return conn;
}

public void freeConnection(Connection conn){
try{
conn.close();
}catch(SQLException sx){
}
}
public void finalize(){
try {
freeConnection(conn);
} catch (Exception ex) {}
}

}
2. 두번째 클래스

아래 클래스도 OracleAdminConnectionManager   를 멤버변수로 선언하고 있습니다.


package xxxxx.db.pool;

import java.sql.*;
import xxxxx.db.*;
import java.io.Reader;
import javax.servlet.http.*;

import xxxxx.util.LogDBAccess;

public class DBAdminAccess  implements HttpSessionBindingListener{

    // DB Connection
    Connection con=null;
    Statement stmt=null;

    PreparedStatement pstmt =null;

    ResultSet result = null;
    OracleAdminConnectionManager mgr = null;
    boolean conInUse = false;
    int pageSize=20;
    boolean hasPrev=false, hasNext=false;
    ResultSubset subset=null;
String test = null;

    public DBAdminAccess() {
    }

    public boolean setConnection(OracleAdminConnectionManager mgr) {
        this.mgr = mgr;
        this.con = mgr.getConnection();
        if (con == null) {
            conInUse=false;
            LogDBAccess.err("Connection is null");
        } else
            conInUse = true;
        return conInUse;
    }

    public boolean setDConnection() {
        this.mgr = new OracleAdminConnectionManager();
        this.con = mgr.getConnection();
        if (con == null) {
            conInUse=false;
            LogDBAccess.err("Connection is null");
        } else
            conInUse = true;

        return conInUse;
    }


    public boolean execute(String sql)
    {
        if (conInUse == false) return false;

        try {
            if (result != null) { result.close(); result=null; }
            if (stmt != null) stmt.close();
            stmt = con.createStatement();
            return (stmt.execute(sql));
        } catch (SQLException E) {
            LogDBAccess.err(E,sql);
            close();
            return false;
        } catch (Exception E) {
            LogDBAccess.err(E,sql);
            close();
            return false;
        }
    }

    public int executeUpdate(String sql)
    {
        if (conInUse == false) return 0;
        try {
            if (result != null) { result.close(); result=null; }
            if (stmt != null) stmt.close();
            stmt = con.createStatement();
            return (stmt.executeUpdate(sql));
        } catch (SQLException E) {
            LogDBAccess.err(E,sql);
            close();
            return 0;
        } catch (Exception E) {
            LogDBAccess.err(E,sql);
            close();
            return 0;
        }
    }

    public boolean execute(PreparedStatement statement) {
        try {
            stmt = statement;
            if (result != null) { result.close(); result=null; }
            return (statement.execute());
        } catch (SQLException E) {
            LogDBAccess.err(E," from prepareStatement execute");
            close();
            return false;
        } catch (Exception E) {
            LogDBAccess.err(E," from prepareStatement execute");
            close();
            return false;
        }
    }

    /*------------------------------------------------------------
        Description : Run Prepared/Callable Statement
        Parameter :
        nType :
            0:PreparedStatement, 1:CallableStatement
        Return Value
            쿼리실행이 성공하면 true, 실패하면 flase
    -------------------------------------------------------------*/
    public boolean execute(int nType)
    {
        if (conInUse == false) return false;

        try {
            if (result != null) {
                result.close();
                result=null;
            }
            return (pstmt.execute());
        } catch (SQLException E) {
            LogDBAccess.err(E);
            close();
            return false;
        } catch (Exception E) {
            LogDBAccess.err(E);
            close();
            return false;
        }
    }

    public PreparedStatement GetPrePareStatement()
    {
        return pstmt;
    }

    /*------------------------------------------------------------
        Description : Create PreparedStatement
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public PreparedStatement prepare(String sql) {
        if (conInUse == false) return null;
        try {
            if (result != null) result.close();
            pstmt = con.prepareStatement(sql);
            return pstmt;

        } catch (SQLException E) {
            LogDBAccess.err(E,sql);
            System.out.println("Esql=" + E);
            close();
            return null;
        } catch (Exception E) {
            LogDBAccess.err(E,sql);
            System.out.println("Esql=" + E);
            close();
            return null;
        }
    }

    /*------------------------------------------------------------
        Description : Create PreparedStatement
        Parameter
            String : 쿼리문
            resultSetType : a result set type; see ResultSet.TYPE_XXX
                TYPE_FORWARD_ONLY : 커서가 앞으로만 이동할수 있다.
                TYPE_SCROLL_INSENSITIVE : Scrollable, not sensitive
                TYPE_SCROLL_SENSITIVE : Scrollable, sensitive
            resultSetConcurrency : a concurrency type; see ResultSet.CONCUR_XXX
                CONCUR_READ_ONLY : Not Updatable
                CONCUR_UPDATABLE : Updatable
        Return Value
            None
    -------------------------------------------------------------*/
    public PreparedStatement prepare(String sql, int resultSetType, int resultSetConcurrency)
    {
        if (conInUse == false) return null;
        try {
            if (result != null) result.close();
            pstmt = con.prepareStatement(sql, resultSetType, resultSetConcurrency);
            return pstmt;

        } catch (SQLException E) {
            LogDBAccess.err(E,sql);
            System.out.println("Esql=" + E);
            close();
            return null;
        } catch (Exception E) {
            LogDBAccess.err(E,sql);
            System.out.println("Esql=" + E);
            close();
            return null;
        }
    }

    /*------------------------------------------------------------
        Description : PreparedStatement 인수값 설정
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void SetPrepareParameter(int nIndex, String strValue)
    {
        try {
            pstmt.setString(nIndex, strValue);
            //System.out.println("SetPrepareParameter(int, String)");
        } catch (Exception E) {
            LogDBAccess.err(E.toString());
            close();
        }
    }

    /*------------------------------------------------------------
        Description :
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void SetPrepareParameter(int nIndex, int nValue)
    {
        try {
            pstmt.setInt(nIndex, nValue);
            //System.out.println("SetPrepareParameter(int, int)");
        } catch (Exception E) {
            LogDBAccess.err(E.toString());
            close();
        }
    }

    /*------------------------------------------------------------
        Description :
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void SetPrepareParameter(int nIndex, float fValue)
    {
        try {
            pstmt.setFloat(nIndex, fValue);
            //System.out.println("SetPrepareParameter(int, float)");
        } catch (Exception E) {
            LogDBAccess.err(E.toString());
            close();
        }
    }

    /*------------------------------------------------------------
        Description :
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void SetPrepareParameter(int nIndex, Date dValue)
    {
        try {
            pstmt.setDate(nIndex, dValue);
            //System.out.println("SetPrepareParameter(int, Date)");
        } catch (Exception E) {
            LogDBAccess.err(E.toString());
            close();
        }
    }

    /*------------------------------------------------------------
        Description :
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void SetPrepareParameter(int parameterIndex, Reader reader, int nLength)
    {
        try {
            pstmt.setCharacterStream(parameterIndex, reader, nLength);
        } catch (SQLException e) {
            System.out.println("JDBCConnection::SetPrepareParameter(int, Date) \n" + e.toString());
            close();
        }
    }

    /*------------------------------------------------------------
        Description : ResultSet 객체 리턴
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public ResultSet getResultSet(int nType) {
        try {
            result = pstmt.getResultSet();
            return result;
        } catch (SQLException E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return null;
        } catch (Exception E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return null;
        }
    }

    /*------------------------------------------------------------
        Description : ResultSet 객체 리턴
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public ResultSet getResultSet() {
        try {
            result = stmt.getResultSet();
            return result;
        } catch (SQLException E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return null;
        } catch (Exception E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return null;
        }
    }

    /*------------------------------------------------------------
        Description : Update Count Return
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public int getUpdateCount() {
        try {
            return stmt.getUpdateCount();
        } catch (SQLException E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return 0;
        } catch (Exception E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return 0;
        }
    }

    /*------------------------------------------------------------
        Description : Update Count Return
        Parameter
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public int getUpdateCount(int nMode) {
        try {
            return pstmt.getUpdateCount();
        } catch (SQLException E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return 0;
        } catch (Exception E) {
            LogDBAccess.err(E," from getResultSet()");
            System.out.println("Esql=" + E);
            close();
            return 0;
        }
    }

    public void setPageSize(int size) {
        pageSize = size;
    }

    public boolean hasPrev() {
        if (subset != null)
            return subset.hasPrev();
        else return false;
    }

    public boolean hasNext() {
        if (subset != null)
            return subset.hasNext();
        else return false;
    }

    public int getTotalPage() {
        if (subset != null)
            return subset.getTotalPage();
        else
            return 0;
    }

    public int getTotalNum() {
        if (subset != null)
            return subset.getTotalNum();
        else
            return 0;
    }

    public ResultSubset getResultSubset(int page) {
        try {
            result = stmt.getResultSet();
            subset = new ResultSubset();
            subset.init(page, pageSize, result);
            return subset;
        } catch (SQLException E) {
            LogDBAccess.err(E," from getResultSubset():SQLException");
            close();
            return subset;
        } catch (Exception E) {
            LogDBAccess.err(E," from getResultSubset():Exception");
            close();
            return null;
        }
    }

    public ResultSetMetaData getMetaData() {
        if (result == null) return null;
        try {
            return result.getMetaData();
        } catch (SQLException E) {
            LogDBAccess.err(E," from getMetaData()");
            close();
            return null;
        } catch (Exception E) {
            LogDBAccess.err(E," from getMetaData()");
            close();
            return null;
        }
    }

    public void setAutoCommit(boolean value) {
        try {
            if (conInUse == true) con.setAutoCommit(value);
        } catch (SQLException E) {
            LogDBAccess.err(E," from setAutoCommit()");
            close();
        } catch (Exception E) {
            LogDBAccess.err(E," from setAutoCommit()");
            close();
        }   finally {
        }
    }

    public void commit() {
        try {
            if (conInUse == true) con.commit();
        } catch (SQLException E) {
            close();
            LogDBAccess.err(E," from commit()");
        } catch (Exception E) {
            close();
            LogDBAccess.err(E," from commit()");
        }
    }

    public void rollback() {
        try {
            if (conInUse == true) con.rollback();
        } catch (SQLException E) {
            LogDBAccess.err(E," from rollback()");
            close();
        } catch (Exception E) {
            LogDBAccess.err(E," from rollback()");

            close();
        }
    }


    /*------------------------------------------------------------
        Description : 모든 자원을 해제한다.
        Parameter :
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void close()
    {
        try {
            if (result != null) { result.close(); result=null; }
            if (stmt != null) { stmt.close(); stmt=null; }
            if (pstmt != null) { pstmt.close(); pstmt=null; }
            if (mgr != null && conInUse == true) {
                // mgr = OracleConnectionManager의 인스턴스
                //System.out.println("DBAdminAccess.close()");
                mgr.freeConnection(con);
                conInUse = false;
            }

            //if (con != null) { con.close(); con=null; }
        } catch (SQLException E) {
            LogDBAccess.err(E," from close()");
        } catch (Exception E) {
            LogDBAccess.err(E," from close()");
        }
    }
/*------------------------------------------------------------
        Description : 모든 자원을 해제한다.(session 종료시 -- test용)
        Parameter :
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void close(String test)
    {
this.test =test;
        try {
            if (result != null) { result.close(); result=null; }
            if (stmt != null) { stmt.close(); stmt=null; }
            if (pstmt != null) { pstmt.close(); pstmt=null; }
            if (mgr != null && conInUse == true) {
                // mgr = OracleConnectionManager의 인스턴스
                //System.out.println("DBAccess.close()");
                mgr.freeConnection(con);
System.out.println("DBAdminSessionAccess Connection close"+test);
                conInUse = false;
            }

            //if (con != null) { con.close(); con=null; }
        } catch (SQLException E) {
            LogDBAccess.err(E," from close()");
        } catch (Exception E) {
            LogDBAccess.err(E," from close()");
        }
    }

/*------------------------------------------------------------
        Description : session이 살때,죽을때 동작을 하는 메소드
        Parameter :
            None
        Return Value
            None
    -------------------------------------------------------------*/
    public void valueBound(HttpSessionBindingEvent event){
        System.out.println("DBAdminSessionAccess binding into Session");
    }



    public void valueUnbound(HttpSessionBindingEvent event){
test ="valueUnbound()";
        try{
close(test);

        }catch(Exception e){
            System.out.println("valueUnbound Exception: "+e);
        }finally{
con = null;
System.out.println("DBAdminSessionAccess unbinding into Session Finally");

}
    }
public void finalize() {
        try {
            close();

        } catch (Exception ex) {}
    }
}


3. 상기 두 클래스를 통해 jsp를 통해 처리되는 형태


<jsp:useBean id="DBMgr" class="xxxxx.db.pool.OracleAdminConnectionManager" />
<jsp:useBean id="access"   scope="page" class="xxxxx.db.pool.DBAdminAccess" />
<% 
         access.setConnection(DBMgr);
         String queryNum= "select * from xxx";
try {
         access.execute(queryNum);
rs = access.getResultSet();

         중략 --

         String sql = "insert into (a, b ,c) xxx value(?,?,?)"
access.prepare(sql.toString());
access.SetPrepareParameter(1,a);
access.SetPrepareParameter(2,b);
access.SetPrepareParameter(3,c);
access.execute(1);
         }catch (Exception e) {

         }finally {
           access.close();
         }


%>
Posted by 나비:D
:

[JAVA] ms-sql2005 최종본

SQL/MSSQL
2007. 12. 17. 20:11

package net.skql.user;

import java.sql.*;

public class ConnectionManager {
 private Connection conn = null;
 private Statement stmt = null;
 private ResultSet rs = null;

 //ms-sql jdbc드라이버 로드
 static final String msjdbc_driver = "com.microsoft.sqlserver.jdbc.SQLServerDriver";  //구문 주의 2000과 틀리삼 ㅡ.ㅜ
 static final String msjdbc_url = "jdbc:sqlserver://127.0.0.1:1433;";
 
 //ms-sql id, password
 private static String msid = "sa";
 private static String mspassword = "1234";
 private static String msdatabase = "testdb";
 
 String url = msjdbc_url;
 
 /**
  * Name : ConnectionManager
  * Desc : 생성자
  */
 public ConnectionManager() {}
 
 public void getDB(dt sqo ) throws Exception{
  String sql = "select * from Comm_member";
 
  try{
   Class.forName(msjdbc_driver);
  }catch(ClassNotFoundException ce){
   System.out.println(ce);
  }
 
  try{
   conn = DriverManager.getConnection(url, msid, mspassword);
   stmt = conn.createStatement();
   rs = stmt.executeQuery(sql);
   while(rs.next()){
    System.out.println(rs.getString(1));
   }
   
  }catch (SQLException se){
   System.out.println(se);
   
  } finally {
   disconnectDB(); //DB와 연결을 끊는다.
  }
 }
 
 public void disconnectDB() throws Exception{
  try{
   conn.close();
   stmt.close();
   rs.close();
  }catch(SQLException se){
   System.out.println(se);
  }
 
 }
 
 public static void main(String[] args){
  ConnectionManager db = new ConnectionManager();
  try {
   db.getDB();
  } catch (Exception e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }
 }
 
}

Posted by 나비:D
:

[JAVA] java msql 연동 2번째

Application/JAVA
2007. 12. 17. 18:57

필요한 JDBC파일들은 올려놓았다.

//------------------------------------------------------------
// Name : ConnectionDB.java
// Desc : Mysql DB와 연결을 담당 하는 클래스
//------------------------------------------------------------

package edu1;

import java.sql.*;

import sun.misc.*;
public class ConnectionDB
{
 
 private Connection conn = null;
 private Statement stmt = null;
 private ResultSet rs = null;
 
 
 //MS-SQL JDBC드라이버 로드
 static final String msjdbc_driver = "com.microsoft.jdbc.sqlserver.SQLServerDriver";

 static final String msjdbc_url = "jdbc:microsoft:sqlserver://203.247.166.172;databasename=project";//DB이름
 
 
 //MSSQL ID, PASSWORD
 private static String msid  = "admin"; //mssql ID
 private static String mspassword = "abc12345"; //mssql password
 
 
 String url = msjdbc_url; //MSSQLJDBC URL
 
 
 //-------------------------------------------------------
 // Name : ConnectionDB
 // Desc : 생성자
 //-------------------------------------------------------
 public ConnectionDB()
 {
 
 
 }
    //-------------------------------------------------------
  // Name : getPublicKey
  // Desc : 데이타베이스와 연결해서 공개키를 가져온다.
 //-------------------------------------------------------
    //통합사이트에서만 키를 가져오면 된다.
    public void getDB() throws Exception
    {
     
     String sql="select *from lathe where id='1'";
     
     //MS-SQL에 연결
     Class.forName(msjdbc_driver).newInstance();
  conn = DriverManager.getConnection(url,msid,mspassword);
  stmt = conn.createStatement();
  rs = stmt.executeQuery(sql);
  while(rs.next()){
   System.out.println(rs.getString(1));
  }
  disconnectDB(); //DB와 연결을 끊는다.
     
    }
   
       
    //-------------------------------------------------------
 // Name : disconnectDB
 // Desc : 데이타베이스와 연결을 끊는다. 
 //-------------------------------------------------------
 public void disconnectDB() throws Exception
 {
  conn.close();
  stmt.close();
  rs.close();
    }
    //main
    public static void main(String[] args)
    {
     ConnectionDB db = new ConnectionDB();
     db.getDB();
     
    }
}

Posted by 나비:D
:

DAO (Data Access Objects) 요약

Application/JAVA
2007. 12. 17. 18:33
위키피디아의 정의에 따르면, DAO (Data Access Objects)는 객체 지향적 설계 패턴의 일종이다. DAO는 애플리케이션에 대하여 하나 이상의 데이터 저장 장치 혹은 관련 소프트웨어에 대한 공통적인 인터페이스를 제공하는 컴포넌트를 의미한다. 즉, 애플리케이션에 대해서는 일관성 있는 데이터 접근을 확보해주는 것이다.

a component which provides a common interface between the application and one or more data storage devices, such as a database or file. The term is most frequently applied to the Object design pattern.

DAO를 활용하면 물리적인 저장 장치가 파일에서 관계형 데이터페이스로 변화하더라도 애플리케이션이 영향을 덜 받도록 해준다. 물리적인 저장은 모두 관계형 데이터베이스를 활용하는 경우에도 제품의 종류나 데이터 접근 오퍼레이션(CRUD 작업)을 돕는 솔루션을 활용에 따라서 실제 구현은 많이 달라지게 된다. DAO와 같은 공통적인 접근 인터페이스를 두지 않는다면, RDBMS 제품이나 활용 솔루션에 변화가 생길 때마다 애플리케이션에도 변경이 필요하게 된다.

DAO는 Core J2EE 패턴으로 소개되었다.
Figure 9.1
Core J2EE 패턴 카타로그에 소개된 클래스 다이어그램과 시퀀스 다이어그램을 참조하면 대략을 이해하는데 도움이 된다.
Figure 9.2
 
BusinessObject
BusinessObject 객체는 데이터를 요구하는 클라이언트를 나타낸다. BusinessObject 객체는 데이터 원본에 접근하여 데이터를 얻거나 저장하기를 요구한다. 일반적으로 서비스 레이어의 객체로 구현하거나, 도메인 객체로 구현한다.

DataAccessObject
DataAccessObject 객체는 DAO 패턴의 중심이다. 기반을 이루는 데이터 접근 구현을 추상화시켜서  BusinessObject 객체가 구체적인 데이터 원본을 고려하지 않고도 접근할 수 있게 한다. 또한, BusinessObject 객체는 DataAccessObject 객체에게 데이터의 로딩 및 저장을 위임한다.

DataSource
데이터 원본에 대한 구현을 나타낸다. 데이터 원본은 RDBMS, OODBMS, XML 저장소, 일반 파일 시스템 등의 데이터베이스이다. 이들 외에 레거시나 메인프레임과 같은 기존의 다른 시스템이나 B2B 기반의 연계 서비스 혹은 LDAP과 같은 류의 저장소가 데이터 원본이 될 수도 있다.

TransferObject
데이터를 운반하는 객체를 나타낸다. DataAccessObject 객체는 BusinessObject 객체에게 데이터를 전달하거나 수정을 위해 데이터를 받기 위해 TransferObject 객체를 사용한다. 서비스 레이어 중심으로 구현을 하는 경우는 대부분의 도메인 객체가 TransferObject 역할을 한다.
아래 다이어그램은 DAO 패턴에 Factory Method를 추가로 적용하여 다수의 RDBMS나 기차 저장장치를 일관성 있게 활용하기 위한 전략을 보여준다.
Figure 9.3
Figure 9.4
Figure 9.5
 
출처:http://younghoe.info/227
Posted by 나비:D
:

고승덕 변호사의 글

etc./Document
2007. 12. 17. 17:39
ㅇ 내 직업은 ① 변호사이면서, ② 방송도 하고, 3년 전부터 ③ 책을 쓰고 있다. 평생 소원이 1년에 1권씩 평생 책을 내는 것이다. ④ 글도 쓴다. 모 신문사에 경제기사를 1주일에 2개정도 쓴다. ⑤ 또 오늘과 같은 특강도 한다. 평균 1주일에 2회 정도. ⑥ 증권분야에서도 활동하고 있다. 운영하고 있는 사이트가 있는데 회원수만도 3만 5천명 정도 된다. 나름대로 홈페이지 관련 사업을 하나 구상중인 것도 있다. ⑦ 마지막으로 대학에서 겸임교수로 활동하고 있다.

이처럼 내가 하고 있는 일이 무척 많은 것 같고 어떻게 이걸 다 할까 생각이 들겠지만 다 가능하다. 이 중에서 한가지만 하더라도 힘들다고 하는 사람이 많다. 그러나 가능하다고 생각하면 다 가능하다.

ㅇ 무엇이든지 목표가 중요하며, 그 목표 달성을 위해 가장 중요한 것은 확신이다. 사람들은 어려운 일일수록 확신을 갖지 못한다.

ㅇ 사람들은 나의 삶을 보면서 머리가 좋다고 생각한다. 그러나 사실은 전혀 그렇지 않다. 다 노력의 결과다.

ㅇ 학교 다닐 때 누구나 학원도 다니고 과외도 해 봤을 것이다. 고 2때 수학 45점의 낙제점수를 받은 적이 있다. 그 때 대학을 못 간다는 선생님의 말이 나에겐 큰 충격이었다. 그러나 집안이 그리 넉넉하지 않았기 때문에 과외를 한다는 것은 생각 할 수 없었다. 그래서 6개월간 죽어라고 했다. 그리고, 그 해 9월 2학기 때 400점 만점에 400점을 받았다. 그 이후로 매 시험마다 1등 했고, 석달에 한 번 정도 2등을 했었다. 학생시절 나는 여러 차례 내가 결코 남들보다 머리가 좋지 않다는 것을 깨달았고, 남보다 더 많은 노력을 해야 남만큼의 결과를 얻을 수 있다는 것을 알았다.

ㅇ 인생에 있어 2가지 자세가 있다.

보통 사람들은 남보다 적게 노력하고 결과는 남들과 같은 똑같이 나오게 하려고 한다. 사실은 이것이 경제학 법칙에 맞는 것이다. 투입을 적게하고 효과를 많이 내는 것.
반대로, 다른 사람들 만큼의 결과를 얻기 위해서는 더 많은 노력을 해야 한다고 생각하는 것이다. 나의 경험상으로 보면 후자가 훨씬 좋은 결과를 낳는다.

남보다 노력을 더 많이 해서 비슷한 결과를 가져 오는 것이 비효율적인 것 같지만, 실제로 이것은 어느 시점이 지나면 훨씬 더 좋은 결과를 가져온다.
이것이 내가 인생을 살면서 내 스스로 내린 결론이다.

ㅇ 그럼 노력이란 무엇이냐? 나는 “노력이란 성공의 확률을 높이는 것이다” 라고 정의 내린다. 하지만 물론 결과를 반드시 보장하지는 않는다. 노력에도 함수 관계가 성립한다.

* 노력 = f(시간 × 집중)

내가 실제 노력을 했는가 안 했는가를 판단하려면 시간을 많이 투입했거나 집중을 잘 했는가를 살펴보면 된다.

ㅇ 똑같은 일을 하더라도 3시간만에 끝내는 사람이 있는가 하면 5시간만에 끝내는 사람도 있다. 그러나 3시간만에 끝내는 사람이 실제 일을 더 잘하는 것 같지만 나머지 2시간을 어떻게 보내느냐가 중요하다. 더 많이 알기 위해 그 2시간을 투자하지 않았다면 노력하지 않은 것이다.

ㅇ 집중에 대해서 얘기해 보면, 고시 공부할 때 예를 들어 보겠다.

나는 고시 공부를 1년간 해서 합격했다. 어떻게 가능 했느냐? 첫째는 된다고 생각하는 확신이 있었기 때문이고, 둘째는 남보다 더 많은 노력을 했기 때문이다. 보통 고시에 합격하려면, 봐야 할 책이 50권, 권당 페이지는 500P, 그 책을 5번을 봐야 합격하다는 얘기가 있다. 그러나 나는 7번을 보았다. 이를 계산해 보면

50 × 500 × 7 = 175,000 페이지를 읽어야 한다는 얘기다. 이것을 1년을 360일로 계산해보면 1일 목표량이 나온다. 즉, 1일 500 페이지 정도의 분량을 봐야 한다는 계산이다.

ㅇ 이처럼, 목표를 세울 때는 구체적으로 세워야 한다. 막연한 목표는 달성하기 힘들다.

이 결론을 보면 "인간이 할 짓이 아니다" 라고 생각할 것이다. 누구나 그렇게 생각한다. 그렇게 생각하면 사람들은 포기하게 된다. 설사 하게 되더라도 하다가 흐지부지 된다. 이렇게 목표에 대해 확신이 없고, 목표를 의심하는 사람은 집중을 할 수 없다. 무엇보다도 자신의 목표에 확신을 가져라.

ㅇ 된다는 사람만 되고 안 된다고 생각하는 사람은 안 된다. 일단 안 된다고 생각하는 대부분의 85%의 사람들은 이미 나의 경쟁상대가 아닌 것이다. 된다고 생각하는 일부만 나의 경쟁이 된다. 그럼 경쟁대상이 줄어드니 훨씬 마음도 한결 가벼워 진다.

ㅇ 세상도 절대적으로 잘 하는 사람은 원하지도 않고 필요하지도 않다. 남 보다만 잘 하면 된다. 그럼, 다른 사람보다 잘 하고 있는지를 어떻게 판단하느냐? 그것은 나 자신을 판단 기준으로 삼으면 된다. 인간은 거의 비슷하다. 내가 하고 싶은 선에서 멈추면 남들도 그 선에서 멈춘다. 남들보다 약간의 괴로움이 추가되었을 때라야 비로소 노력이란 것을 했다고 할 수 있다.

ㅇ 고시 공부할 때 7시간 잤다. 장기간 공부를 해야 할 경우라면 일단 잠은 충분히 자야 한다. 하루 24시간 중 나머지 17시간이 중요하다. 고시생의 평균 1일 공부시간은 10시간 정도다. 그러나 정말 열심히 하는 사람은 잠자는 시간 빼고 17시간을 하는 사람이 있을 것이다라는 생각을 했다. 그러면 정말, 밥 먹는 시간도 아까웠다. 남들과 똑같이 먹어서는 안 된다고 생각한 것이다. 반찬 떠 먹는 시간도 아까웠다. 씹는 시간도 아까웠다. 그래서 모든 반찬을 밥알 크기로 으깨어 밥과 비벼 최대한의 씹는 시간도 아꼈다. 숟가락을 놓는 그 순간부터 공부는 항상 계속 되어야 했다. 나의 경쟁자가 설마 이렇게까지 하겠냐 하고 생각들면 노력했다고 할 수 있는 것이다.

ㅇ 미국에서 생활 할 때 보면 소위 미국의 전문가라고 하는 사람들은 간단한 샌드위치로 끼니를 때운다. 점심시간 1시간 다 쓰고, 이래저래 20~30분 또 그냥 보내는 우리 나라 사람들은 그들에 비하면 일 하는게 아니다.

ㅇ 집중을 잘 하는 것은 벼락치기 하는 것이다. 벼락치기 할 때가 더 기억에 오래 남는다고 한다. 우등생은 평소에 벼락치기 하는 마음으로 공부를 한다.

이렇게 할 수 있는 이유는 목표가 분명하기 때문이다. 막연한 목표를 가지면 이렇게 긴장이 안되지만 분명하면 항상 긴장되고 집중을 잘 할 수 있다.

ㅇ 방송하면서 인생이 많이 바뀌었다. 처음 주변 사람들은 말렸지만 결과적으로 보면 좋은 결과를 가져왔다.

나는 세상을 살면서 이런 생각을 해 본다. 사람은 해야 할 일과 하지 말아야 할 일이 있다. 사람이 해야 할 일이란 남에게 해를 끼치는 일이 아니면 해도 되는 일이다 라고 생각한다. 그렇게 생각하면 세상에 해야 할 일이 참 많다.

ㅇ 나에게는 인생 철학이 있다. 인생을 살다 보면 A와 B가 있을 때 나는 A가 더 중요하지만 B를 선택해야 할 경우가 많다. 그럴 때 어떤 것을 선택하느냐는 매우 중요하다.

학교 다닐 때 나는 A는 여자친구 였고, B는 고시 합격 이었다. 대학시절 한 때 A는 내게 무척 중요한 시기가 있었다. 여기서 내가 말하는 t1,t2판단법이란게 중요하다. 내가 A를 선택하면 난 B를 성공할 수 있는 확률은 줄어든다. 그러나, 나의 외모 컴플렉스 때문에 A를 성공하는 일 또한 확신이 없었다. 그래서 나는 B를 먼저 해서 좀 더 유리한 조건이 되면 A도 이룰 수 있다고 생각했다. 그렇게 결론을 내리면 고시합격을 더 빨리 해야 할 필요성을 느끼게 되어 집중도 잘 되었다.

이것이 내가 인생을 살아가면서 느낀 것이다. 장기간 동안 시간의 흐름을 계산해 볼 때 무엇을 먼저 해야 하는가를 판단하는 것은 매우 중요하다.

ㅇ 그래서 난 남들이 말려도 우스꽝스러운 모습으로 코미디 프로에도 나갈 수 있었다. 난 " 할 수 있을 때 뭐든지 해 버리자 " 라는 생각으로 할 수 있는 건 다 한다. 그러면서 인생에서 내가 할 수 있는 일들을 쌓아 가면 된다. 하다가 안되면 포기하더라도 아예 안 하는 것보다는 낫다. 아예 하지 않으면 할 수 있는 일은 아무 것도 없다.

ㅇ 나의 징크스는 시험에 합격하려면 10번을 봐야 하는 것이다. 그래야 합격의 확신을 갖는다. 3~4번만 보면 불안하다. 그래서 그냥 뭐든지 기본적으로 10번을 본다. 몇 번 3~4번 책을 보고 시험을 본 적 있다. 역시 떨어졌다.


[ 결 론 ]

ㅇ 앞으로는 이렇게 해 보자. 첫째는 남보다 많이 노력하는 것이다. 둘째는 어려운 목표일수록 확신을 가져 보자. 그러면 정말 되는 일이 훨씬 많다. 셋째는 남보다 최소 3배는 해야 한다고 생각하자.

ㅇ 직장에서 윗 사람이 일을 시킬 때 남보다 더 많은 일을 시키고, 나한테만 어려운 일을 시키더라도 신나는 표정을 지어보자. 대부분의 사람, 아니 나의 경쟁자는 이럴 때 얼굴을 찌푸릴 것이다. 그러나 내가 이기려면 그들 보다는 다른 모습이어야 한다. 힘들더라도 괴로움을 추가해 보자.

ㅇ 남들에 비해 노력한 만큼의 결과가 나오지 않더라도 노력을 계속해야 한다. 3배의 노력만 한다면 4번째 부터는 분명 가속도가 붙어 급속도로 차이가 날 것이다.

ㅇ 마지막으로 대인관계에 대해 강조하고 싶다. 세상을 살다보면 대인관계를 유지하는 것도 노력이다. 성공을 위해서는 나 혼자의 노력 외에 대인관계가 차지하는 비중이 높은 경우가 있다. 어떤 상대를 만나든 최소 5분은 상대방을 위해 생각하는 시간으로 할애해 보자.

ㅇ 남과 똑같이 해서는 절대 노력했다고 할 수 없다.
Posted by 나비:D
:
◀ PREV : [1] : [···] : [17] : [18] : [19] : [20] : [21] : [22] : [23] : [···] : [28] : NEXT ▶
BLOG main image
by 나비:D

공지사항

카테고리

분류 전체보기 (278)
Programming? (0)
---------------------------.. (0)
나비의삽질 (5)
Application (177)
SQL (51)
Web (27)
etc. (14)
Omnia (0)
---------------------------.. (0)

최근에 올라온 글

최근에 달린 댓글

최근에 받은 트랙백

태그목록

MSsql function ADO procedure Android DOM hooking C mysql Delphi Excel jsp visual studio 2005 Excel 문자열 xml Java datagrid HashTable svn Bluelab Oracle C# 내장함수 형변환 flex NSIS DbUtils Visual Basic 6.0 delphi Eclipse

글 보관함

달력

«   2024/12   »
일 월 화 수 목 금 토
1 2 3 4 5 6 7
8 9 10 11 12 13 14
15 16 17 18 19 20 21
22 23 24 25 26 27 28
29 30 31

링크

Total :
Today : Yesterday :
rss